从机器学习到大模型：原理、实践与前沿

一段程序怎样从数据中学会预测？一个接着一个地预测文字，为什么能让模型写文章、回答问题，甚至帮助我们编程？面对接连出现的新论文，我们又该怎样判断：哪些进展值得认真学习，哪些结论还需要再看一看？

这本书想和你一起弄清这些问题。

我们会从一个小小的预测任务出发，先认识数据、模型和训练，再走进神经网络、Transformer 与大语言模型。沿途既要动笔算一算，也要把代码跑起来。遇到一个新方法时，我们关心它解决了什么问题，也关心它会在什么地方出错。

如果你写过一些程序，记得高中数学中的函数和概率，就可以开始。微积分、线性代数和更深入的统计知识会在需要时逐步补上。刚开始不必记住所有术语；让一个小例子在自己的电脑上跑通，往往比背下一页定义更有收获。

从基础走向前沿

全书前半部分围绕机器学习和深度学习展开，后半部分进入大模型的训练、应用、部署与多模态。最后，我们会一起读论文、设计实验，尝试验证一个研究结论。新研究也会陆续加入前沿专题库，与前面的基础知识连起来。

学习路线从导读一路延伸到第四十七章。前四篇带你整理数学工具、训练机器学习模型，再亲手计算神经网络的梯度和注意力，做出一个能续写短句的小型 Transformer。第五、第六篇接着研究数据、计算预算、指令与奖励：模型怎样学得更好，又会在哪些地方学偏？

到了应用部分，我们为一家虚构工坊做资料与工具助手，让它查找证据、查询预约、计算报价，再检查事情究竟有没有办成。部署部分则把等待时间、内存和服务并发摆到台前。多模态部分让模型看图、画图、听声音、读视频；那些认错、画偏和听漏的结果，也值得认真分析。

最后一篇从一篇校准论文出发，练习读公式、核对实验、重做方法，并把证据整理成一份可以交给别人复查的小型研究报告。遇到工具或符号上的障碍，可以随时翻到附录，不必让一个陌生名字挡住整条思路。

前沿专题把这些基础接到仍在发展的研究问题。你可以观察模型如何保存过去、使用额外计算、吸收新知识，也可以让小车按预测行动，或在可解释性与可靠性中拆开一个自信却答错的模型。每个专题都注明资料日期，区分已有证据与仍待检验的想法。

你可以先看看怎样读这本书，也可以直接翻到导读，从一个日常问题开始：打印一份 24 页的文档，大约需要多久？

怎样读这本书

你不需要等到“数学全准备好了”才开始学习机器学习。带着一个问题往前走，遇到不熟悉的知识再回来补，通常更容易知道自己为什么要学它。

从哪里开始

建议先读导读。我们会用几十行 Python 代码预测打印耗时，亲手走一遍训练、比较和预测的过程。这个例子很小，却能帮你认清后面反复出现的几个角色：数据、模型、参数和误差。

接下来，可以从函数、向量与矩阵顺着读。前四篇会把数学工具、模型训练、神经网络与语言模型连成一条路线；第五、第六篇再讨论预训练、指令、偏好与奖励。每篇末尾都有实践，适合停下来，把前面零散学到的东西接成一次完整实验。

如果更关心应用，可以在熟悉模型评估与 Transformer 以后进入第七、第八篇：先做资料与工具助手，再研究运行成本和服务。第九篇把输入扩展到图像、声音和视频；第十篇则带你围绕校准问题读论文、重做实验、检查统计证据，最后写成报告。

附录 A～H适合随时翻查。前沿专题库可以按兴趣选择，不必从头追到尾：例如，先问“多想一会儿有没有帮助”，再读推理与测试时计算；先问“它为什么答得这么自信”，再看可解释性与可靠性。每个专题开头都会指出所需基础。

遇到公式时，先找它在回答什么问题

看到新符号，不妨先问：输入是什么？最后要算出什么？中间这一步为什么需要？

例如，预测打印耗时时，“每页需要的时间 × 页数 + 固定开销”就是一个模型。先弄懂这句话，再把它写成公式，符号就有了落脚点。暂时看不懂一段推导，也可以先代入一组数字算算，或回到图上看看它描述的关系。

本书需要的数学会逐步展开。函数、向量、概率或导数忘了都没关系，数学部分可以当作随手查阅的工具。

让代码替你检验理解

第一次运行例子时，先保留原来的数据和设置，看看能否得到书中的结果。第二次再改一个条件：换几条数据，调整一个参数，或故意给模型一道难题。先猜结果，再运行，最后解释差异。 这三步很适合用来检查自己是否真的理解了一个方法。

前七章的脚本只使用 Python 标准库；第八章开始使用 NumPy 和 scikit-learn，第十四章开始用 PyTorch 训练网络。对应章节会说明环境安装方法，也提供固定版本的依赖清单。当前例子都在 CPU 上运行过，不要求 GPU。

第三十一章起还提供真实预训练模型的可选实验，需要下载模型并预留数 GB 内存。你也可以先运行标准库示例、阅读随书保存的完整生成记录，再决定是否重做模型推理。两种方式的区别会在章节中说明；后续实验也请先看相应的环境要求。

每次做完实验，留下几行笔记就好：改了什么、原先怎么想、实际发生了什么。过一段时间再回头看，这些记录会比“我好像已经学过了”可靠得多。

不急着追完每一篇新论文

前沿研究更新很快，基础知识却能反复帮上忙。读到新方法时，先看看它想解决什么问题，与已有方法相比改了哪一步，实验又支持了多大的结论。

遇到感兴趣的方向，可以从前沿专题库继续探索。暂时读不懂的地方，常常也会提醒你下一步值得补哪些基础。

现在，就从打印耗时这个小问题开始吧。

导读：用一个预测任务认识机器学习

你把一份 24 页的文档交给打印机，屏幕上弹出一句话：“预计还需 92 秒。”

这个数字是怎么来的？

如果知道打印机每页需要几秒、启动又需要多久，写一个计算程序并不难。可现实中的设备没那么整齐：传输、预热、进纸都可能带来一些波动。我们手上往往只有过去的记录——打印了多少页，最后用了多少秒。

不妨试试从这些记录里找一条规律。找到以后，再拿几次新任务检验：它预测得准不准？这就是我们走近机器学习的第一步。

这一章里，我们会亲手做完这件事。只要你还记得一次函数和平均数，能看懂简单的 Python 循环与函数，就可以跟上。读到最后，你会知道模型到底“学”到了什么，也能让它在自己的电脑上作出预测。

1. 先说清楚：我们要预测什么

我们的目标是：在提交打印任务时，根据文档的页数，估计从提交到最后一页输出要花多少秒。

先把场景缩小一点：始终使用同一台打印机，采用单面黑白打印；开始时没有其他任务排队，纸张和设备也都正常。这样，我们就能先看清页数与耗时的关系。

这些条件很有用。想想看，同样是 10 页文档，前面排着十几个任务时，等候时间可能比打印时间还长。如果把这样的记录混在一起，却只告诉模型页数，它自然很难猜准。

下面的数据是为方便学习而编出的例子，并非真实测量结果。我们把数字和数据量都控制得很小，好让每一步都能亲手核对。

我们要预测的是“多少秒”这样的数值，这类任务叫回归。如果把问题改成“能否在 90 秒内完成”，答案就变成“能”或“不能”，这类任务则叫分类。先记住这两个名字，后面还会遇见它们。

2. 从一张小表格开始

一条记录里有什么

先来看 6 次打印任务：

每一行描述一次任务，我们称它为一条样本。用来作预测的页数叫特征，希望预测的实际耗时叫标签。把这些样本放在一起，就得到一个数据集。

“标签”听起来像一个类别名称，但这里的 37 秒、47 秒同样是标签。你可以把它理解成历史记录中已经知道的答案。模型学习时能看到这些答案；等一份新文档刚提交时，真正的耗时还没有发生，只能先作预测。

这里用 $x$ 表示页数，$y$ 表示实际耗时。以后也可以给模型更多信息，例如是否双面、是否彩色。眼下先只用页数，把问题看清楚。

如果亲自收集数据，还要留意单位和缺失记录。例如，某次忘了计时，应该标明缺失，不能填成 0 秒——“没记下来”和“瞬间打印完”可不是一回事。

留一些记录，等会儿再看

假如一个程序背下了上面这张表，遇到 5 页就回答 37 秒，遇到 10 页就回答 47 秒，它在这 6 条记录上可以一题不错。但来了 12 页的文档，它该怎么回答？

所以，我们不能只用模型看过的记录来评价它。开始训练之前，就把本例的 12 条记录分成三份：

本例直接给出固定划分，三份数据没有重复记录。6∶3∶3 只是为了方便演示，实际项目不必照搬这个比例。

可以把测试集想成一份暂时封存的考卷。如果每改一次模型就翻开答案看一看，再根据成绩继续修改，它就不再是一场独立的考试了。即使文件还叫“测试集”，它也已经影响了我们的选择。

真实数据还多一层讲究。例如，要预测未来的任务，就可以用较早的记录训练、较晚的记录测试；同一次任务的重复副本也不能分散到训练集和测试集中，否则模型相当于提前见过了考题。

3. 让一条直线试试看

先选一个简单的模型

回头看看表格：页数越多，耗时大致也越长。一个很自然的猜法是：

预计耗时 = 每页增加的时间 × 页数 + 一段固定开销。

写成你熟悉的一次函数，就是：

$$\hat{y}=ax+b$$

这里，$x$ 仍然是页数；$\hat{y}$ 读作“$y$ 帽”，表示预测耗时，用来和实际耗时 $y$ 区分。$a$ 表示每多一页预计增加多少秒，$b$ 则表示模型中的固定耗时，单位是秒。

这条从输入算出预测值的规则，就是我们的模型。其中，$a$ 和 $b$ 是还需要确定的两个参数。我们先选了一次函数的形式，接下来让数据帮助确定它们的数值。

不妨先试 $a=3$、$b=20$。打印 5 页，模型会预测：

$$\hat{y}=3\times5+20=35$$

也就是 35 秒。实际记录是 37 秒，少估了 2 秒，看上去还不错。但只看一条记录可不够，我们得看看它在全部训练记录上的表现。

顺便提醒一句：虽然 $b$ 可以表示某种固定开销，却不能仅凭拟合结果就认定“这台打印机预热恰好用了 20 秒”。参数描述的是数据中的关系，具体的设备机制还需要另外测量。

给预测打个分

怎样把 6 次预测的好坏合成一个分数？

最直接的想法是，逐条计算“预测值减去实际值”，再取平均。但这样有个问题：一次多估 2 秒、另一次少估 2 秒，加起来就变成了 0。两个错误竟然互相抵消了。

我们换个办法：把每次误差先平方，再求平均。这样得到的分数叫均方误差，英文缩写是 MSE。

对于 $a=3$、$b=20$，6 次预测依次为 35、50、65、80、95、110 秒。减去对应的实际耗时，误差就是 $-2$、$3$、$-1$、$-1$、$3$、$-2$ 秒。因此：

$$\begin{aligned} L &= \frac{4+9+1+1+9+4}{6} \\ &= \frac{28}{6}\approx 4.67 \end{aligned}$$

我们用 $L$ 表示这个分数，也叫损失。在同一份训练集上，损失越小，说明按这个标准衡量的预测误差越小。平方还有一个效果：大误差会被罚得更重。

注意，误差平方后，单位也变成了“秒的平方”。所以这里的 4.67 不能理解成“平均差了 4.67 秒”。稍后我们会换一个更方便用秒解释的指标。

训练：让程序替我们找参数

现在可以让程序帮忙了：尝试一组参数，算出损失，再尝试下一组，最后保留损失最小的那组。

先固定 $b=20$，只看三个候选值：

这三组里，$a=3$ 明显更合适。后面的代码会多试一些：$a$ 从 0 到 5，每次增加 0.5；$b$ 从 0 到 40，每次增加 1。一共是 $11\times41=451$ 组参数。

程序逐一比较后，选出的仍然是 $a=3$、$b=20$。利用训练数据，按照损失寻找合适参数的过程，就叫训练。 在这个小例子里，所谓“学会了”，最终落实为两个数。

当然，程序只找到了这 451 组中的最佳选择。我们给了它多大的搜索范围、每一步迈多远，都会影响结果；真正更好的数值可能落在两步之间。换了数据，选出的参数也可能变化。

这种逐个尝试的办法叫枚举，优点是容易看懂。等模型有成千上万甚至更多参数时，就不能这样试遍所有组合了。到那时，我们会用梯度下降等更高效的方法。

到这里，模型和训练算法就各司其职了：模型按 $\hat{y}=ax+b$ 作预测，训练算法负责找到 $a$ 和 $b$。

4. 预测得好不好，总得有个比较

先和一个简单办法比一比

训练损失看起来很小，但这个模型值得用吗？先找一个简单的办法当作比较对象，也就是基线。

我们的基线干脆不看页数，每次都猜训练集中耗时的平均值：

$$\frac{37+47+66+81+92+112}{6}=72.5$$

也就是每次都猜 72.5 秒。这个办法很粗糙，却能帮我们回答一个实在的问题：加入页数、再训练两个参数，究竟带来了多少改善？

这里的平均值也只能从训练集计算。验证集和测试集里的答案，还要留着做各自的工作。

用验证集选方案

现在打开预留的验证集。两个方案都已从训练集准备好，我们只让它们作预测，不用这些新记录重新拟合参数。

这次用平均绝对误差来比较，英文缩写是 MAE。做法很简单：每条记录先算“差了多少秒”，不管偏大还是偏小，再取平均。它的单位仍然是秒，读起来更直观。

下表除页数外，其余数值都以秒计。最后一列是线性模型的绝对误差。

算一算，两个方案的验证 MAE 是：

• 基线：$(29.5+3.5+30.5)/3\approx21.17$ 秒。
• 线性模型：$(1+2+1)/3\approx1.33$ 秒。

在这三条记录上，线性模型好得多。于是，我们选它，并固定 $a=3$、$b=20$。

你可能已经注意到：训练时用 MSE，这里却用了 MAE。这是可以的。前者让大误差受到更重的惩罚，后者方便我们用秒来理解结果。训练和评估也可以使用同一个指标，关键是知道每个数字代表什么。

最后再看测试集

方案选好了，才轮到此前没有参与训练和选择的测试集。下表仍然以页数作输入，其余三列的单位都是秒：

测试 MAE 为：

$$\frac{2+1+3}{3}=2$$

也就是说，这个固定下来的模型在这 3 次测试中，平均相差 2 秒。

能据此保证“以后每次最多差 2 秒”吗？不能——表格里就有一次差了 3 秒。平均值并不是上限，也不能保证未来的平均误差恰好还是 2 秒。何况我们只有几条教学数据，足够演示方法，还不足以说明真实打印机上的效果。

真实应用需要更多能代表未来任务的记录。至于差多少秒才算够好，还要看用途：给用户一个大概的等候时间，和精确安排一条生产线，对误差的要求显然不同。

测试成绩也不该变成反复修改模型的提示。如果看过测试结果后继续调整方案，下一轮就需要新的独立数据，才能作出可信的最终评估。

5. 回到那份 24 页的文档

还记得开头的问题吗？现在终于可以回答了。把 $x=24$ 代入已经选好的模型：

$$\hat{y}=3\times24+20=92$$

预计需要 92 秒。屏幕上那句话，就可以这样产生。

这个使用已训练模型计算输出的过程叫推理，在这个例子里也就是预测。“推理”在这里不一定指人的逻辑推导，它首先是运行模型的计算过程。

这一次计算不会自动改变 $a$ 和 $b$。我们换一个页数，模型就给出另一个预测，参数仍然是原来的两个数。要继续学习新记录，需要另行安排训练。至于这次预测究竟差多少，还得等文档真正打印完才知道。

图 1：训练时，我们用已知答案寻找参数；推理时，把新输入交给选好的模型。

再把这些数字画出来：

图 2：不同形状的点代表已有记录，直线表示模型的预测，星号是 24 页文档的预测值。直线只用训练集拟合；验证点和测试点画在这里，是为了方便比较。

如果希望明天还能运行这个模型，就需要把它保存下来。在本例中，要记住一次函数的形式、两个参数，以及输入输出的单位；适用设备、数据版本和评估结果也值得一并保存。以后遇到神经网络，参数会多得多，但保存模型及其配套配置这件事仍然少不了。

6. 用起来之后，还有什么可能出错

从提出问题到给出预测，我们已经走完了一次小实验。把前面的步骤连起来，就是下面这张图：

图 3：开发过程中可以根据验证结果改进方案。测试集留到方案固定后使用，投入使用后还要继续观察实际效果。

图的最后一步容易被忽略。假如办公室换了打印机，或大家开始大量打印彩色文档，旧模型还合适吗？我们需要把新任务的预测和实际耗时对照起来，看看误差有没有变化。条件变了，就可能需要重新收集数据、训练和评估。

此外，还有三个常见的坑，值得提前认识。

只会做见过的题。 一个模型可能把训练记录里的细节记得非常牢，在训练集上一题不错，换了新数据却表现很差。这可能是过拟合。因此，训练损失越低，不一定意味着模型越好用。

偷偷看到了答案。 假设有人把“最后一页输出的时间”也放进输入，离线实验的分数可能一下子变得漂亮。可提交任务时，根本不可能知道这个时间！这就是一种数据泄漏：训练或评估用到了实际预测时不该知道的信息。前面反复利用测试答案调模型，也会让评估失去独立性。

走到了没见过的范围。 我们的训练记录只有 5～30 页，公式却照样能算 300 页。这个结果可信吗？设备可能中途散热、补纸，耗时不再按同样的规律增长。把预测伸到已有数据范围之外，叫外推。公式算得出来，不代表现有证据足够支持它。

我们希望模型在没参与训练、又符合实际使用场景的新数据上仍然表现良好。这种能力叫泛化能力。留出数据来验证和测试，正是为了了解它学到的规律能走多远。

7. 在自己的电脑上试一遍

先把程序跑起来

这个案例只用 Python 标准库。准备好 Python 3.9 或更高版本，一台普通电脑就能运行。

如果你已经下载了本书仓库，在仓库根目录执行：

python3 src/examples/printing_time.py

也可以下载完整脚本，进入文件所在目录后执行：

python3 printing_time.py

部分环境中的命令叫 python 或 py，使用自己电脑上可用的那个即可。

对着代码，认出刚才的步骤

TRAIN、VALIDATION 和 TEST 保存三份数据。predict 负责预测，mse 和 mae 分别计算两种误差，train 搜索参数，main 则把训练、选择和测试串起来。

读到 range(11) 时，留意它产生的是 0 到 10 的整数；再除以 2，就得到间隔为 0.5 的候选值。float("inf") 是正无穷，用来给“目前最小的损失”设一个初值。** 2 表示平方，abs 取绝对值。

"""导读案例：用页数预测打印耗时。仅使用 Python 标准库。"""

# 每个二元组都是（页数，实际耗时/秒）。数据为教学构造，并非真实测量。
TRAIN = [(5, 37), (10, 47), (15, 66), (20, 81), (25, 92), (30, 112)]
VALIDATION = [(8, 43), (18, 76), (28, 103)]
TEST = [(12, 58), (22, 85), (26, 101)]


def predict(pages, a, b):
    return a * pages + b


def mse(data, a, b):
    """均方误差：逐条计算误差的平方，再取平均。"""
    total = 0.0
    for pages, actual in data:
        error = predict(pages, a, b) - actual
        total += error ** 2
    return total / len(data)


def mae(data, a, b):
    """平均绝对误差：逐条计算误差的绝对值，再取平均。"""
    total = 0.0
    for pages, actual in data:
        total += abs(predict(pages, a, b) - actual)
    return total / len(data)


def train(data):
    # 只用训练集，在 11 × 41 = 451 组候选参数中选择。
    best_loss = float("inf")
    best_parameters = None
    for step in range(11):
        a = step / 2  # 0、0.5、1、……、5
        for b in range(41):  # 0、1、2、……、40
            loss = mse(data, a, b)
            if loss < best_loss:
                best_loss = loss
                best_parameters = (a, b)
    return best_parameters


def main():
    # 基线也只用训练集：无论页数多少，都预测训练耗时的平均值。
    mean_time = sum(actual for _, actual in TRAIN) / len(TRAIN)
    a, b = train(TRAIN)
    print(f"训练得到：a={a:.1f}, b={b:.1f}")
    print(f"训练 MSE：{mse(TRAIN, a, b):.2f} 秒²")

    # 用验证集选择模型方案，不用测试集调参。
    candidates = {"均值基线": (0, mean_time), "线性模型": (a, b)}
    best_name = None
    best_score = float("inf")
    for name, (candidate_a, candidate_b) in candidates.items():
        score = mae(VALIDATION, candidate_a, candidate_b)
        print(f"{name}的验证 MAE：{score:.2f} 秒")
        if score < best_score:
            best_score = score
            best_name = name

    # 方案到此固定，测试结果不再用于修改它。
    a, b = candidates[best_name]
    print(f"选定方案：{best_name}")
    print(f"测试 MAE：{mae(TEST, a, b):.2f} 秒")

    # 对一个尚未实际打印的新任务进行预测。
    print(f"24 页的预测耗时：{predict(24, a, b):.0f} 秒")


if __name__ == "__main__":
    main()

看看结果是否和手算的一样

运行后，你应该看到：

训练得到：a=3.0, b=20.0
训练 MSE：4.67 秒²
均值基线的验证 MAE：21.17 秒
线性模型的验证 MAE：1.33 秒
选定方案：线性模型
测试 MAE：2.00 秒
24 页的预测耗时：92 秒

这份程序没有随机步骤，只要数据和代码相同，结果就相同。如果数字对不上，先回头检查数据、搜索范围，以及平方和绝对值是否写对。

跑通以后，先别急着关掉窗口。试着改一条训练记录，猜猜参数会不会变，再重新运行。把改动前后的结果记下来，你就开始做自己的小实验了。

8. 从两个参数，走向大模型

我们刚才做的事情属于机器学习：利用已有数据寻找一条能用于新任务的规则。它是人工智能中的一类方法；人工智能还包括依靠人工编写规则来完成任务的方法。

如果把一次函数换成多层神经网络，就走进了深度学习。你暂时可以把神经网络理解为许多带有可调参数的计算步骤连接在一起，“深”表示这样的计算有多层。模型复杂了许多，但我们依然需要准备数据、定义学习目标、训练和评估。

再把输入换成文本，把网络和数据规模扩大，就能逐步接近现代大语言模型。当然，仅仅“变大”还不够，后面还有模型结构、数据处理和训练方法等许多问题要学。处理图像、音频等信息的大模型也会在后续章节登场。

不同模型从哪里得到学习的线索呢？本章中，每条训练样本都同时给出了页数和实际耗时，这叫监督学习。另外几种常见方式是：

• 自监督学习：从数据自身构造答案。例如，给出一句话的前半段，让模型预测后面的文字，用原文中的后续内容检查预测。
• 无监督学习：没有事先指定的目标标签，尝试从数据里找结构，例如把相似的记录分成几组。
• 强化学习：采取行动后，根据获得的奖励反馈，学习怎样作出更好的选择。

它们说的是学习线索从哪里来；前面的“回归”和“分类”说的是要完成什么任务，两组名字回答的问题不同。

以逐步生成文字的自回归语言模型为例，文本会先被切成 Token，也就是模型处理的文字片段。一个 Token 可能对应一个字、一个词，也可能只是词的一部分，并不总和日常说的“单词”一致。

训练时，模型根据前面的 Token 预测下一个 Token，再拿原文中的实际后续内容计算损失。生成时，则根据模型给出的概率选择下一个 Token，把它接到已有文本后面，继续下一步。

看起来和打印耗时相距很远，骨子里却仍能认出熟悉的步骤：用输入作预测，拿答案计算损失，再调整参数。不过，接出一句流畅的话，与核实一句话是否真实，是两回事。后面学习大模型应用时，我们还会专门讨论怎样检验事实、借助外部资料，并识别不可靠的回答。

9. 停一下，自己试试

先想一想，或在纸上算一算，再展开答案。

1. 按刚才的模型，16 页文档预计需要多久？这个数是标签还是预测值？
2. 训练 MSE 约为 4.67，能说“平均差 4.67 秒”吗？测试 MAE 为 2 秒，能说“每次最多差 2 秒”吗？
3. 训练得到 $a=3$、$b=20$ 后，再预测一份新文档，这两个参数会自动变化吗？
4. 如果一个模型把 6 条训练记录全部记住，训练误差为 0，还需要验证和测试吗？
5. 把实际打印结束时间也交给模型，能帮助它在提交任务时预测吗？
6. 修改代码，输出每条测试记录的预测值和绝对误差，再算一次平均值。你是在检查计算，还是在重新训练？

for pages, actual in TEST:
    predicted = predict(pages, a, b)
    print(pages, predicted, actual, abs(predicted - actual))

如果还想多试一步：固定 $b=20$，让 $a$ 在更细的范围内变化，画出训练损失的曲线。先猜最低点在哪里，再运行程序看看。这次只需要训练集，让测试集继续留作独立评估。

10. 带着这个例子继续往前

到这里，你已经让一条直线从数据中“学”出了两个参数，也亲手检查了它的预测。后面遇到神经网络、注意力机制和 Transformer 时，可以时常回头想想这个小例子：输入是什么？参数在哪里？它在用什么答案学习？我们又凭什么相信它的输出？

接下来，可以继续读函数、向量与矩阵，把一份文档的预测扩展到多个特征和一批任务。学过数学基础后，线性回归会带你用梯度重新训练这个模型；怎样读这本书中有全书的阅读路线。

想看看另一种讲解，可以阅读 Google 机器学习速成课程中的线性回归和训练集、验证集与测试集。带着已经跑通的小例子去读，许多术语会熟悉得多。

函数、向量与矩阵

在导读里，我们让一条直线预测打印耗时：

$$\hat{y}=3x+20$$

给它 24 页，它就回答 92 秒。到这里，只有一个输入、一个输出，看起来还很轻巧。

现在给问题加一点变化：一份文档里既有黑白页，也有彩色页，怎么办？如果同时来了三份文档，要逐份写三遍公式吗？再多一台速度不同的打印机，又该怎样比较？

函数、向量和矩阵，正好能帮我们把这些事情说清楚。你可以把这一章看作一次整理：先把计算写成函数，再把相关的数字装进向量，最后把一批计算排进矩阵。每次引入一个新名字，都让它做一点实际的事。

本章需要的数学不超过一次函数、坐标和勾股定理。点积的角度解释会用到余弦；如果暂时忘了，也可以先看例子，稍后再回来。

1. 函数：给计算规则起个名字

同一条规则，可以反复使用

把导读里的模型记作：

$$f(x)=3x+20$$

$f$ 是函数的名字，$x$ 是输入。$f(24)$ 的意思是“把 24 交给函数 $f$ 计算”，因此 $f(24)=92$。

函数规定了输入和输出的对应关系：每一个允许的输入，都有唯一的输出。这里允许的输入是文档页数，实际使用时应是非负整数；纸上画直线时，我们也可以把它扩展到实数，观察整条曲线。

这里的“唯一”说的是给定输入后，输出已经确定，并不要求不同输入一定得到不同输出。例如，一个总是返回 72.5 的基线，也是函数。

在 Python 里，可以这样写：

def predict(pages):
    return 3 * pages + 20

数学函数与这段程序讲的是同一件事。只是一般的程序函数还可能读写文件、修改状态；此刻我们专注于这种给定输入、计算输出的简单形式。

函数也不一定画成直线。例如，正方形的边长为 $s$ 时，面积函数是 $h(s)=s^2$：边长从 2 变成 4，面积从 4 变成 16。输入翻倍，输出却变成了四倍。我们先从直线入手，是因为容易算、容易画；“输入经过一条规则得到输出”这个想法，适用于更丰富的关系。

输入在变，还是规则在变

如果换一台更慢的打印机，可能需要每页 4 秒；如果启动更慢，固定开销可能变成 40 秒。把两个数留成可调的参数，就得到：

$$f_{a,b}(x)=ax+b$$

下标 $a,b$ 提醒我们：这里其实有一整组函数。固定 $a=3$、$b=20$，才选中了其中一条。

• 改变 $x$：还是同一个模型，只是换了一份文档。
• 改变 $a$ 或 $b$：计算规则变了，也就是换了模型参数。

看看这几条线：

图 1：$a$ 决定页数增加时耗时涨得多快；$b$ 决定直线从多高的位置开始。图中不同线型对应不同参数，都是用于说明关系的假设。

导读中的训练，就是借助数据挑选参数。这一章先把参数设好，集中研究怎样组织计算，暂时不再训练新模型。

一个函数的输出，也能交给另一个函数

假如界面希望显示分钟，而模型输出秒，可以再写一个换算函数：

$$g(t)=\frac{t}{60}$$

$t$ 是秒数。先算 $f(24)$，再把结果交给 $g$：

$$g(f(24))=\frac{92}{60}\approx1.53$$

这叫函数复合，也就是把两次计算接起来。程序里对应 g(f(24))。

顺序要看清楚：内层先算，外层后算。这里先预测秒数、再换算成分钟才符合含义。以后看到一层接一层的神经网络，也可以先从“上一层的输出，交给下一层”这个角度理解。

2. 向量：一份文档，不止一个数字

现在允许文档包含黑白页和彩色页。我们把每一页归到其中一类，不重复计数。一份有 10 页黑白、2 页彩色的文档，可以记成：

$$\mathbf{x}= \begin{bmatrix} 10\\ 2 \end{bmatrix}$$

这就是一个向量：按约定顺序排好的一组数。粗体 $\mathbf{x}$ 表示整组数，$x_1$ 和 $x_2$ 表示其中的第一个、第二个分量。

顺序很重要。这里约定第一项是黑白页数，第二项是彩色页数。把它们交换，就变成了另一份文档。数字本身不会告诉程序自己代表什么，解释数字的约定也必须一起保留。

一个数，例如固定耗时 20，叫标量。上面的向量有两个分量，是一个二维向量。遇到 $\mathbf{x}\in\mathbb{R}^2$，可以读成“$\mathbf{x}$ 是由两个实数组成的向量”；符号 $\mathbb{R}$ 表示实数集合。虽然页数只取非负整数，我们仍可以把这样的记录放进实数向量中讨论。

同一组数，也可以画成箭头

暂时放下页数，看看平面中的向量：

$$\mathbf{u}= \begin{bmatrix}3\\2\end{bmatrix}$$

它可以表示“向右走 3 步，再向上走 2 步”。从原点出发，箭头就指向坐标 $(3,2)$。箭头平移到别的位置，只要方向和长度不变，表示的仍是同一个位移向量。

向量既可以是一份特征记录，也可以是一段位移。后者很适合用来理解运算，但不要因此认为所有特征都必须有一个真实的空间方向。等到向量有几百个分量时，画不出来也不影响逐项计算。

相加与缩放，都从每个分量开始

再取一个向量 $\mathbf{v}=[1,2]^{\mathsf T}$。这里的上标 $\mathsf T$ 表示转置，把横着写的一行转成竖着的一列；这样可以在一句话中紧凑地写出列向量。

把两个向量相加，就是对应位置相加：

$$\mathbf{u}+\mathbf{v} = \begin{bmatrix} 3+1\\2+2 \end{bmatrix} = \begin{bmatrix}4\\4\end{bmatrix}$$

从走路的角度看，先走 $\mathbf{u}$，再从它的终点走 $\mathbf{v}$，总位移就是 $(4,4)$。

图 2：向量相加可以首尾相接。虚线箭头与实线橙色箭头代表同一个 $\mathbf{v}$，只是起点不同。

乘上一个标量，则让每个分量都乘它：

$$2\mathbf{u}= \begin{bmatrix}6\\4\end{bmatrix}, \qquad -\mathbf{u}= \begin{bmatrix}-3\\-2\end{bmatrix}$$

乘 2，箭头沿原方向变成两倍长；乘 $-1$，箭头掉头，长度不变。两个向量相减，也可以理解成加上反方向的向量。

在打印任务中，两份文档的页数向量相加，可以算出合计的黑白页数和彩色页数。但这不表示把两份任务合并后，总耗时一定等于原来两份耗时之和：固定开销是付一次还是两次，还要看实际怎样提交任务。

3. 点积：把几项贡献合成一个数

从页数到耗时

先假设每页黑白需要 3 秒，每页彩色需要 5 秒，每份文档还有 20 秒固定开销。这些是本章为便于计算设定的参数，并非从彩色打印数据训练出来的结果，也不代表真实设备的速度。

对于 10 页黑白、2 页彩色的文档：

$$\hat{y}=10\times3+2\times5+20=60$$

预计耗时为 60 秒。先不看最后的 20，前面的计算就是“对应相乘，再全部相加”。这个操作叫点积。

把两个每页耗时装进权重向量 $\mathbf{w}=[3,5]^{\mathsf T}$，就可以写成：

$$\mathbf{x}\cdot\mathbf{w} =x_1w_1+x_2w_2 =40$$

“权重”在这里描述每个特征对结果的影响：黑白页数每增加 1，预测增加 3 秒；彩色页数每增加 1，预测增加 5 秒。最后加上的固定项通常叫偏置，记作 $b$。于是模型变成：

$$\hat{y}=\mathbf{x}\cdot\mathbf{w}+b$$

看一眼单位，也能帮我们检查这个式子：页数乘以每页耗时，得到的是秒。黑白页贡献 30 秒，彩色页贡献 10 秒，两项可以相加；再加上 20 秒固定开销，才是完整的预测耗时。这里的权重不只是两个数字，它们还带着“秒/页”的含义。

两个参数乘两个特征，只是开头。如果有 $d$ 个特征，规则仍然一样：

$$\mathbf{x}\cdot\mathbf{w} =\sum_{j=1}^{d}x_jw_j$$

$\sum$ 是求和符号，意思是让 $j$ 从 1 走到 $d$，把每一项 $x_jw_j$ 加起来。向量必须有同样多的分量，并且对应位置的含义要对得上。

点积还有一个几何解释

回到刚才的箭头 $\mathbf{u}=[3,2]^{\mathsf T}$ 和 $\mathbf{v}=[1,2]^{\mathsf T}$：

$$\mathbf{u}\cdot\mathbf{v} =3\times1+2\times2=7$$

用勾股定理，$\mathbf{u}$ 的长度为：

$$\|\mathbf{u}\| =\sqrt{3^2+2^2} =\sqrt{13}$$

两侧的双竖线表示这里使用的欧几里得长度，也叫 L2 范数。你可以先把它当作勾股定理在向量上的写法。

点积为什么会和角度扯上关系？先把两根箭头的起点放在一起，从 $\mathbf{v}$ 的终点向 $\mathbf{u}$ 所在的直线作垂线，垂足记作 $P$。从原点到 $P$ 的这段路，就是 $\mathbf{v}$ 沿 $\mathbf{u}$ 方向留下的“影子”，数学上叫投影。

图 3：把橙色箭头投到蓝色箭头所在的直线上。虚线与蓝色方向垂直，绿色线段是投影；它比橙色箭头短。

图中的夹角记作 $\theta$。还记得直角三角形里的“邻边除以斜边”吗？橙色箭头是斜边，所以投影长度等于 $\|\mathbf{v}\|\cos\theta$。再乘上蓝色箭头的长度，就得到点积。在通常的直角坐标系中，两个非零向量满足：

$$\mathbf{u}\cdot\mathbf{v} =\|\mathbf{u}\|\,\|\mathbf{v}\|\cos\theta$$

这里的投影要带上方向：如果夹角超过 $90^\circ$，垂足就落在 $\mathbf{u}$ 的反方向上，投影的有向长度为负。向量越朝着同一个方向，余弦越接近 1；垂直时余弦为 0；指向相反方向时余弦为 $-1$。因此，点积同时受到长度和方向影响。

回到图中的两个向量，点积是 7，蓝色箭头的长度是 $\sqrt{13}$，所以绿色投影的长度为：

$$\frac{\mathbf{u}\cdot\mathbf{v}}{\|\mathbf{u}\|} =\frac{7}{\sqrt{13}}\approx1.94$$

图形与数字说的是同一件事：$\mathbf{v}$ 长约 2.24，沿着 $\mathbf{u}$ 的方向看，只留下了约 1.94。

取几个容易核对的例子：

如果只想比较方向，就可以除掉两个长度，得到余弦相似度：

$$\cos\theta= \frac{\mathbf{u}\cdot\mathbf{v}} {\|\mathbf{u}\|\,\|\mathbf{v}\|}$$

零向量没有方向，也不能放进这个除法。对于其他向量，点积大也未必意味着方向更接近：把一个向量放大十倍，就会让点积也放大十倍，方向却完全没变。

以后讨论文本向量和检索时，我们会再遇到这些量。眼下先记住，它们是计算工具；特征的单位、尺度和表示方式，会影响“远近”与“相似”的含义。把米换成厘米，数字扩大百倍，实际物体却并没有走远。

4. 矩阵：把一批任务排在一起

一行一份文档，一列一种特征

假设现在有三份文档：

把表格中的数字保留下来，就得到矩阵：

$$X= \begin{bmatrix} 10&2\\ 4&6\\ 8&0 \end{bmatrix}$$

矩阵就是按行、列排列的数。 这个矩阵有 3 行、2 列，形状记作 $3\times2$。在本章的数据约定中，行数告诉我们有多少条样本，列数告诉我们每条样本有多少个特征。

记住“先行、后列”，再看 $X_{2,1}=4$ 就很自然了：它是第 2 行、第 1 列，也就是第二份文档的黑白页数。这里数学下标从 1 开始，Python 列表下标从 0 开始，所以代码对应的是 X[1][0]。

我们此前把单份文档写成列向量 $\mathbf{x}$，这里却把它放在了矩阵的一行。两者不矛盾：这一行写的是 $\mathbf{x}^{\mathsf T}$。转置只交换行列位置，不改变每个数代表的内容。

例如，整个矩阵转置后：

$$X^{\mathsf T}= \begin{bmatrix} 10&4&8\\ 2&6&0 \end{bmatrix}$$

形状从 $3\times2$ 变成 $2\times3$。现在每一列是一份文档，每一行是一种特征。无论选哪种排法，后面的计算都要遵守同一套约定。

矩阵乘向量，就是每一行做一次点积

给三份文档都用同一组权重 $\mathbf{w}=[3,5]^{\mathsf T}$。逐行计算，得到：

$$X\mathbf{w} = \begin{bmatrix} 10\times3+2\times5\\ 4\times3+6\times5\\ 8\times3+0\times5 \end{bmatrix} = \begin{bmatrix}40\\42\\24\end{bmatrix}$$

这就是矩阵与向量相乘。每一行提供一份文档的特征，与权重做一次点积，于是每一行得到一个数。

最后，每个结果都要加一次 20 秒固定开销：

$$\hat{\mathbf{y}} = \begin{bmatrix} 40+20\\42+20\\24+20 \end{bmatrix} = \begin{bmatrix}60\\62\\44\end{bmatrix}$$

三份文档分别预测为 60、62、44 秒。这里算的是每份文档单独作为一次任务时的耗时，没有把排队等待或合并打印算进去。

还记得前面说过，“页数可以相加，耗时却未必直接相加”吗？现在就能算清楚了。把前两份文档合成一个任务，共有 14 页黑白、8 页彩色。沿用同一条预测规则，只付一次固定开销：

$$14\times3+8\times5+20=102$$

分开提交时，预测耗时之和是 $60+62=122$ 秒；合成一个任务后，预测为 102 秒。少掉的 20 秒，恰好是省下来的一次固定开销。页数向量相加没有问题，但算耗时之前，还得说清楚我们在处理几次任务。

如果希望写成一句紧凑的公式，可以用 $\mathbf{1}=[1,1,1]^{\mathsf T}$ 表示全为 1 的向量：

$$\hat{\mathbf{y}}=X\mathbf{w}+b\mathbf{1}$$

$b\mathbf{1}$ 就是 $[20,20,20]^{\mathsf T}$。这样相加的两个对象都是三项列向量，每一项的固定开销都清清楚楚。

再检查一下形状：$X$ 是 $3\times2$，$\mathbf{w}$ 作为列向量是 $2\times1$，输出是 $3\times1$。中间的两个 2 对应同样的两种特征；它们必须匹配，逐项相乘才有意义。

5. 矩阵乘矩阵：一次比较两台打印机

现在多了一台打印机。第一台仍然使用权重 $[3,5]^{\mathsf T}$，第二台假设使用 $[2,4]^{\mathsf T}$。把两组权重并排放好：

$$W= \begin{bmatrix} 3&2\\ 5&4 \end{bmatrix}$$

这里，每列是一台打印机的权重。第一行对应黑白页，第二行对应彩色页。别因为它恰好有两行两列，就忽略行、列各自的含义。

我们要把三份文档分别交给两套规则计算。结果的第 1 行、第 2 列，应该是“第一份文档在第二台打印机上的加权耗时”：

$$10\times2+2\times4=28$$

用同样的办法填完其他位置：

$$XW= \begin{bmatrix} 40&28\\ 42&32\\ 24&16 \end{bmatrix}$$

结果中的每一项，都是左边的一行与右边的一列做点积。 这就是矩阵乘法的计算规则。

不妨用手指沿着下面的图走一遍：先选中第一份文档，再找到第二台打印机，黑白页配黑白页的耗时，彩色页配彩色页的耗时。算出的 28，落在结果表中这份文档与这台打印机相交的位置。

图 4：选一行、配一列，就能填好结果中的一格。底部其余数字用同样的方法算出，暂时都没有加固定开销。

为什么非得“一行配一列”？因为我们把一份文档的特征横着排，把一台打印机的权重竖着排。两边都按“黑白、彩色”的顺序，对应位置才是一对可以相乘的数。矩阵乘法把刚才逐份、逐台的点积统一写了出来。

若左边有 $n$ 份样本、每份 $d$ 个特征，右边有 $k$ 组权重，那么：

$$\underbrace{X}_{n\times d} \underbrace{W}_{d\times k} = \underbrace{Z}_{n\times k}$$

这里 $Z$ 是乘积的名字。共同的 $d$ 是每次点积要计算的项数，结果则保留了 $n$ 份样本和 $k$ 个输出。用下标写，就是：

$$Z_{ij}=\sum_{\ell=1}^{d}X_{i\ell}W_{\ell j}$$

$i$ 选左边的一行，$j$ 选右边的一列，$\ell$ 沿着共同的特征逐项走过去。看不顺眼时，先回到刚才的 $10\times2+2\times4$，它就是这个式子的一个具体位置。

还差固定开销。假设第一台为 20 秒，第二台为 30 秒，就给每一行的第一列加 20、第二列加 30，得到：

$$\hat{Y}= \begin{bmatrix} 60&58\\ 62&62\\ 44&46 \end{bmatrix}$$

于是，这个简单模型认为第一份文档在第二台上更快，第二份一样快，第三份在第一台上更快。所有数字都来自设定好的规则，目前没有真实数据来说明两台设备是否真的如此。

在一些数值计算库里，把同一组偏置自动加到每一行的做法会用到广播。它是一套明确的形状规则，并不意味着任意两个不同形状的数组都可以相加。本章代码会把逐行加偏置的过程直接写出来。

别把两种乘法混在一起

向量 $[3,2]$ 和 $[1,2]$ 对应位置相乘，得到的是 $[3,4]$；做点积，则还要加起来，得到 7。前一种叫逐元素乘法，结果中保留了每个位置；后一种把它们合成了一个数。

矩阵也一样：逐元素乘法通常要求同样的形状，而矩阵乘法要求左边的列数等于右边的行数。具体库可能额外支持广播，使用时仍需查清楚约定。

还有一个容易踩的坑：矩阵乘法通常不能交换顺序。本例 $XW$ 能算，$WX$ 却连形状都对不上：$2\times2$ 右乘 $3\times2$，中间的 2 和 3 不相等。即便两种顺序都能算，结果也未必相同。下一节会看到，顺序其实对应“先做哪一步”。

6. 矩阵还能改变一张方格纸

刚才把矩阵看成表格，是为了管理数据。现在换个角度：把一个矩阵看成作用在向量上的函数。

取：

$$A= \begin{bmatrix} 2&1\\ 0&1 \end{bmatrix}$$

给它一个平面向量 $\mathbf{p}=[x,y]^{\mathsf T}$，它会输出：

$$A\mathbf{p} = \begin{bmatrix} 2x+y\\ y \end{bmatrix}$$

第二个坐标保持不变；第一个坐标先加倍，再加上原来的第二个坐标。例如：

$$A\begin{bmatrix}1\\2\end{bmatrix} = \begin{bmatrix}4\\2\end{bmatrix}$$

如果把方格纸上的每个点都这样变换，原来的正方形会变成平行四边形：

图 5：蓝色和橙色箭头分别表示水平、竖直方向的单位向量。矩阵 $A$ 把它们送到 $(2,0)$ 和 $(1,1)$；绿色点从 $(1,2)$ 移到 $(4,2)$。

这个变换有一个很方便的观察方法。向量 $[x,y]^{\mathsf T}$ 可以理解成“$x$ 份水平单位向量，加上 $y$ 份竖直单位向量”。变换之后：

$$A\begin{bmatrix}x\\y\end{bmatrix} = x\begin{bmatrix}2\\0\end{bmatrix} + y\begin{bmatrix}1\\1\end{bmatrix}$$

右边那两个向量，恰好就是 $A$ 的两列。矩阵的每一列，告诉我们对应的单位向量被送到了哪里。 这就是理解矩阵几何意义的一条捷径。

矩阵乘向量给出的是线性变换。它保留向量相加和标量缩放的关系：

$$\begin{aligned} A(\mathbf{u}+\mathbf{v})&=A\mathbf{u}+A\mathbf{v}\\ A(c\mathbf{u})&=c(A\mathbf{u}) \end{aligned}$$

$c$ 是一个标量。因此，“先把两段位移加起来，再变换”和“分别变换，再相加”会得到同一结果。线性变换也一定把零向量送回零向量。

如果在变换后再加一个固定向量，让整张图平移，就得到仿射变换。严格地说，带有非零固定项的 $f(x)=ax+b$ 也是仿射函数；机器学习里仍习惯把带偏置的这类预测方法称为线性模型。两个名字出现在不同语境中，不必因此怀疑前面的直线。

再想想函数复合：先做矩阵 $A$ 表示的变换，再做矩阵 $D$ 表示的变换，可以写成 $D(A\mathbf{p})=(DA)\mathbf{p}$。右边的 $A$ 先作用，这和 g(f(x)) 从内向外计算是同样的顺序。练习里，我们会亲手比较换序前后的结果。

7. 从形状看懂张量

一份文档有两个数字，三份文档排成两条轴的表格。如果数据是一批彩色图片，情况又会怎样？

一张图片有高度、宽度，每个位置还有红、绿、蓝三个通道。再把多张图片放在一起，就需要更多条轴来定位一个数字。

在机器学习代码里，我们通常用张量来称呼这种规则排列的多维数组。本章先采用这个计算上的理解；不需要现在就掌握更一般的数学定义。

括号中的数字依次告诉我们每条轴有多长；(2,) 中的逗号表示这个形状只有一条轴。

这里有两个“维”容易混淆：一个有 100 个分量的向量，可以叫 100 维向量；保存它的一维数组，却只有一条轴。前者说有多少个坐标分量，后者说要用几个索引才能取到一个数。

还有，纸上的列向量和代码里的一维数组也要区分。长度为 2 的一维数组形状是 (2,)，显式的列矩阵形状是 (2, 1)，行矩阵则是 (1, 2)。它们都存两个数，但在数组运算中并不总能互换。后面的标准库代码用一维列表保存向量，行列含义由我们调用的运算决定。

不同程序也可能把图片通道放在前面，使用 (8, 3, 32, 32)。所以，看到一个形状时，不只要数数字，还要问：这一条轴究竟代表什么？

以后遇到形状错误，可以按三步查：先解释每条轴的含义，再核对运算要求，最后检查结果应该保留哪些轴。不要仅仅为了让程序跑通，就随意交换行列或重排元素。

8. 用几十行 Python 把它们串起来

运行方式

下面的脚本只使用 Python 标准库，Python 3.9 或更高版本即可运行。

如果已经下载本书仓库，在根目录执行：

python3 src/examples/vectors_matrices.py

也可以单独下载脚本，在保存它的目录执行：

python3 vectors_matrices.py

部分电脑上的命令是 python 或 py，换成自己的可用命令即可。

先看懂三个小步骤

dot 做点积，matvec 让矩阵的每一行做一次点积，matmul 再把“每行配每列”的计算展开。

matmul 里的三个循环和公式一一对应：i 选择结果的行，j 选择列，k 沿共同的特征维度，把乘积累加起来。这里的 shape 是我们自己写的函数，用来检查二维列表是否为矩形，并返回行数、列数。

zip 会把两个列表的元素逐项配对，但遇到较短的列表就停止，所以 dot 会先检查分量个数，避免漏掉分量。这里比较的是 len 返回的元素数量，不是几何上的向量长度。列表的 + 在 Python 中表示拼接，* 与整数一起使用表示重复；它们不会自动替我们完成这里的向量加法和矩阵乘法。

"""第一章示例：Python 3.9+，只使用标准库。参数均为教学设定。"""

from math import sqrt


JOBS = [[10, 2], [4, 6], [8, 0]]  # 每行依次是黑白页数、彩色页数
WEIGHTS = [3, 5]                 # 两类页面分别需要的秒数
BIAS = 20                       # 每份文档的固定开销
MODEL_WEIGHTS = [[3, 2], [5, 4]]  # 每列对应一台打印机
MODEL_BIASES = [20, 30]
U = [3, 2]
V = [1, 2]
TRANSFORM = [[2, 1], [0, 1]]


def linear(pages, a=3, b=20):
    return a * pages + b


def dot(u, v):
    if len(u) != len(v):
        raise ValueError("点积要求两个向量的分量数相同")
    return sum(left * right for left, right in zip(u, v))


def shape(matrix):
    if not matrix or not matrix[0]:
        raise ValueError("这个示例只处理非空矩阵")
    columns = len(matrix[0])
    if any(len(row) != columns for row in matrix):
        raise ValueError("矩阵的每一行必须一样长")
    return len(matrix), columns


def matvec(matrix, vector):
    _, columns = shape(matrix)
    if columns != len(vector):
        raise ValueError("矩阵的列数必须等于向量的分量数")
    return [dot(row, vector) for row in matrix]


def matmul(left, right):
    rows, inner = shape(left)
    right_rows, columns = shape(right)
    if inner != right_rows:
        raise ValueError("左矩阵的列数必须等于右矩阵的行数")
    result = []
    for i in range(rows):
        row = []
        for j in range(columns):
            value = 0
            for k in range(inner):
                value += left[i][k] * right[k][j]
            row.append(value)
        result.append(row)
    return result


def main():
    seconds = linear(24)
    print(f"24 页：{seconds} 秒，约 {seconds / 60:.2f} 分钟")
    print("u + v =", [a + b for a, b in zip(U, V)])
    print("2u =", [2 * value for value in U])
    print("u · v =", dot(U, V))
    u_length = sqrt(dot(U, U))
    v_length = sqrt(dot(V, V))
    print(f"u 的长度：{u_length:.3f}")
    print(f"v 沿 u 方向的投影长度：{dot(U, V) / u_length:.3f}")
    print(f"u 与 v 的余弦相似度：{dot(U, V) / (u_length * v_length):.3f}")

    print("X 的形状：", shape(JOBS))
    weighted = matvec(JOBS, WEIGHTS)
    print("Xw =", weighted)
    print("一台打印机的预测（秒）：", [value + BIAS for value in weighted])

    raw = matmul(JOBS, MODEL_WEIGHTS)
    predicted = [[value + MODEL_BIASES[j] for j, value in enumerate(row)]
                 for row in raw]
    print("XW =", raw)
    print("两台打印机的预测（秒）：", predicted)
    print("A 作用于 [1, 2]：", matvec(TRANSFORM, [1, 2]))


if __name__ == "__main__":
    main()

对照手算结果

运行后应得到：

24 页：92 秒，约 1.53 分钟
u + v = [4, 4]
2u = [6, 4]
u · v = 7
u 的长度：3.606
v 沿 u 方向的投影长度：1.941
u 与 v 的余弦相似度：0.868
X 的形状： (3, 2)
Xw = [40, 42, 24]
一台打印机的预测（秒）： [60, 62, 44]
XW = [[40, 28], [42, 32], [24, 16]]
两台打印机的预测（秒）： [[60, 58], [62, 62], [44, 46]]
A 作用于 [1, 2]： [4, 2]

这里没有随机过程，也没有训练步骤。代码是在执行我们设定的函数和矩阵运算。u 的长度只显示了三位小数；$\sqrt{13}$ 本身并不恰好等于 3.606。

第一次跑通后，试着把第一份文档的彩色页数从 2 改为 3。先不运行，猜猜两台打印机的预测各增加多少秒，再用程序验证。这样的改动很小，却能检查你是否真的把“特征、权重和输出”连在了一起。

我们用循环，是为了看清每个数怎样算出来。以后处理大批数据时，会把相同的运算交给数值库完成，省去手写循环，也更方便利用高效的计算实现。

9. 自己动手，把符号变成熟悉的东西

1. 对于 $f_{a,b}(x)=ax+b$，把输入从 10 改为 12，和把 $a$ 从 3 改为 4，有什么不同？取 $a=3,b=20$ 时，$f(12)$ 是多少？
2. 一份文档有 6 页黑白、3 页彩色，按第一台打印机的参数，预测耗时是多少？如果把这两个特征的位置写反了，却没有调整权重，会得到多少？
3. 已知 $\mathbf{u}=[3,2]^{\mathsf T}$、$\mathbf{v}=[1,2]^{\mathsf T}$，求 $\mathbf{u}-\mathbf{v}$、它的长度，以及 $\mathbf{u}$ 与 $\mathbf{v}$ 的逐元素乘积。
4. $X$ 的形状为 $5\times3$，$W$ 为 $3\times4$，那么 $XW$ 是什么形状？若数据按本章的方式排列，各个数字代表什么？
5. 为什么在矩阵 $X$ 的右边乘 $\mathbf{w}=[3,5]^{\mathsf T}$ 可以计算，却不能直接右乘三个分量的权重向量？
6. 取 $D=\begin{bmatrix}1&0\\0&2\end{bmatrix}$，它会把竖直坐标加倍。使用本章的 $A$ 和 $\mathbf{p}=[1,2]^{\mathsf T}$，分别算 $A(D\mathbf{p})$ 与 $D(A\mathbf{p})$。结果相同吗？
7. 把脚本中的第一份文档改成 [10, 3]。先猜两台打印机的预测，再运行核对。接着故意让 dot([1, 2], [3]) 运行一次，看看为什么要先检查分量个数。
8. 一批图片的形状是 (8, 32, 32, 3)，若按本章的轴顺序解释，共存了多少个数字？它有几条轴？
9. 把 $\mathbf{v}=[1,2]^{\mathsf T}$ 放大十倍，$\mathbf{u}$ 保持不变。点积、投影长度和余弦相似度各会怎样变化？先看图 3 想一想，再用代码中的 dot 和 sqrt 核对。

from vectors_matrices import TRANSFORM, matmul, matvec

D = [[1, 0], [0, 2]]
p = [1, 2]

print(matvec(TRANSFORM, matvec(D, p)))  # [6, 4]
print(matvec(D, matvec(TRANSFORM, p)))  # [4, 4]
print(matmul(TRANSFORM, D))            # [[2, 2], [0, 2]]
print(matmul(D, TRANSFORM))            # [[2, 1], [0, 2]]

进阶选做：用循环写一个 transpose 函数，把本章的 $3\times2$ 矩阵变成 $2\times3$。用已经知道的结果核对，再试着连续转置两次。你应该回到原矩阵，而且每个数字的位置也都恢复了。

10. 下一步，怎样找到更好的参数

一开始，我们只有“页数乘 3，再加 20”。现在，同样的思路已经可以写成一个处理多种特征、多份样本的模型。函数说明怎样从输入得到输出，向量把相关的数组织起来，矩阵让一批相似的计算有了清楚的结构。

接下来，还有一个在导读中暂时靠枚举解决的问题：参数稍微改一点，损失会怎样变？能不能顺着让损失变小的方向走，而不必逐个试遍？

这正是下一章导数、梯度与优化要讨论的问题。继续往前读之前，可以先用本章的代码改改输入和权重，让这些运算真正变得熟悉。

如果想多看一些图形解释，可以从 MIT 线性代数课程的几何入门继续探索。想对照机器学习中常见的符号，则可以选读 Goodfellow、Bengio 和 Courville 所著《深度学习》的第 2 章：线性代数，先看 2.1 和 2.2 节即可；后面的逆矩阵、特征分解等内容可以暂时放下。

导数、梯度与优化

在导读里，我们让程序试遍 451 组参数，再挑出预测误差最小的一组。两个参数时还好办；假如每个参数有 100 种选择，十个参数就有 $100^{10}$ 种组合。再勤快的循环，也很难逐一试完。

能不能不用每条路都走一遍，而是先看看：往哪边挪一点，损失会变小？

导数和梯度，正是用来回答这个问题的。它们不神秘：先观察一个量变动时，另一个量怎样跟着变；再把这种关系用到参数更新中。

1. 从“平均每页多几秒”到变化率

先看熟悉的函数 $f(x)=3x+20$。输入从 10 增加到 12，输出从 50 增加到 56。输出的变化除以输入的变化：

$$\frac{f(12)-f(10)}{12-10}=\frac{6}{2}=3$$

这个比值叫这段区间上的平均变化率。在打印模型里，单位是秒/页；在图上，它是连接两个点的直线斜率。

一次函数的斜率处处相同。曲线就未必了。为了容易手算，换成 $f(x)=x^2$，看看 $x=2$ 附近：

这里算的都是：

$$\frac{f(2+h)-f(2)}{h}$$

这叫差商。把平方展开，会发现：

$$\frac{(2+h)^2-2^2}{h} =\frac{4h+h^2}{h} =4+h$$

只要 $h\ne0$，这个等式就成立。$h$ 越接近 0，结果就越接近 4。我们把这个极限叫作函数在 2 处的导数，写成 $f'(2)=4$。

一般地：

$$f'(x)=\lim_{h\to0}\frac{f(x+h)-f(x)}{h}$$

$\lim$ 表示“观察它趋近的值”。这里不是把 $h=0$ 塞进分母，而是看 $h$ 从两侧越来越接近 0 时，差商是否趋向同一个有限值。

图 1：两个点之间的割线描述平均变化；导数则描述一个点附近的变化趋势。

如果函数在某点可导，附近一小步可以这样估计：

$$f(x+h)\approx f(x)+f'(x)h$$

例如，$2.01^2$ 可以估成 $4+4\times0.01=4.04$；精确值是 4.0401。步子小的时候，这个局部近似很有用，但走远了就不一定准。

导数也不是处处存在。例如 $|x|$ 在 0 处有个尖角：从左看斜率是 $-1$，从右看是 1，没有唯一的切线斜率。后面遇到这样的函数时，需要相应的处理方法。

2. 换一个横轴：现在调整的是参数

刚才讨论输入 $x$ 怎样改变输出。训练时，我们关心的通常是：参数怎样改变损失。

先拿一个容易看清的教学损失函数练手：

$$L(w)=(w-3)^2$$

横轴是参数 $w$，纵轴是损失 $L$。最低点显然在 $w=3$。我们已经知道答案，但先让程序假装不知道，看看能否顺着局部变化找到它。

用刚才展开平方的办法，可以得到：

$$L'(w)=2(w-3)$$

当 $w=0$ 时，导数为 $-6$：向右挪一小步，损失会下降。当 $w=5$ 时，导数为 4：向右会升高，应该向左走。

也就是说，我们可以朝导数的反方向移动：

$$w_{\text{new}}=w-\eta L'(w)$$

希腊字母 $\eta$ 读作 eta，这里表示正的学习率，用来决定步子大小。导数告诉我们方向和局部变化快慢，学习率控制这次实际走多远。

例如，从 $w=0$ 出发，取 $\eta=0.1$：

$$w_{\text{new}}=0-0.1\times(-6)=0.6$$

损失从 9 降到 $(0.6-3)^2=5.76$。再计算新位置的导数，继续走。这种反复更新的过程，就是梯度下降在单参数情形下的样子。

注意，这里的 $w$ 已经是参数，不是某份文档的页数。区分“在改变输入”还是“在调整参数”，比记住字母叫什么更重要。

3. 步子大一点，会不会更快

有时会，有时却会冲过头。

对这个特定的二次函数，更新式还能整理成：

$$w_{\text{new}}-3=(1-2\eta)(w-3)$$

左边是更新后离最低点的差，右边是原来的差乘上一个系数。于是可以直接看出：

图 2：四次实验都从 0 出发。能否收敛，取决于步长与当前损失曲面的形状是否匹配。

这里 $\eta=0.5$ 的表现特别好，只是因为我们挑了这个简单函数。换成 $100(w-3)^2$，曲线陡了一百倍，同一个学习率就可能太大。输入和损失的尺度，也会影响训练是否稳定。

因此，不存在一个对所有模型都合适的学习率。实际训练常会观察损失曲线，比较几种候选步长，必要时逐渐减小它。后面做完整模型时，我们还会用验证集判断方案效果，而不是只看训练损失下降得快不快。

4. 两个参数时，分别问两次

回到直线模型，取一条教学样本：$x=2$，实际答案 $y=7$。预测为 $\hat y=wx+b$，平方损失为：

$$L(w,b)=(wx+b-y)^2$$

现在可以调整 $w$，也可以调整 $b$。如果只想知道 $w$ 的影响，就先把 $b$ 固定；只想知道 $b$ 的影响，就把 $w$ 固定。这种“其他参数暂时不动”的导数叫偏导数。

符号 $\partial L/\partial w$ 表示对 $w$ 的偏导。我们先不急着背结果，而是把计算拆成两步：

$$e=wx+b-y,\qquad L=e^2$$

$e$ 是预测误差。参数先改变误差，误差再改变损失。这是上一章函数复合的具体例子。

误差增加一点，损失的变化率是 $2e$；$w$ 增加一点，误差的变化率是 $x$。把这两段关系乘起来：

$$\frac{\partial L}{\partial w} =\frac{dL}{de}\frac{\partial e}{\partial w} =2ex$$

同理，$b$ 增加 1，误差也增加 1，所以：

$$\frac{\partial L}{\partial b}=2e$$

这就是链式法则：沿着“谁影响谁”的计算顺序，把相邻两步的变化率接起来。对于一般的复合函数 $g(f(x))$，对应的是 $g'(f(x))f'(x)$，外层的导数要在内层输出处计算。

取 $w=2,b=0$，预测为 4，误差 $e=-3$，因此：

$$\frac{\partial L}{\partial w}=-12,\qquad \frac{\partial L}{\partial b}=-6$$

把所有偏导按参数顺序排成向量，就是梯度：

$$\nabla L= \begin{bmatrix} \partial L/\partial w\\ \partial L/\partial b \end{bmatrix}$$

$\nabla$ 读作 nabla。这个新符号里装的，仍然是两个已经算出来的数。

取学习率 0.05，同时更新两个参数：

$$\begin{aligned} w_{\text{new}}&=2-0.05\times(-12)=2.6\\ b_{\text{new}}&=0-0.05\times(-6)=0.3 \end{aligned}$$

新预测为 5.5，损失从 9 降到 2.25。两个偏导都要在同一组旧参数处计算，再一起更新。 如果改完 $w$ 才重新计算 $b$ 的偏导，那就是另一种更新过程了。

5. 从一条样本走向整个训练集

设有 $n$ 条样本，第 $i$ 条为 $(x_i,y_i)$。把每条平方误差平均，得到导读中用过的 MSE：

$$L(w,b)=\frac1n\sum_{i=1}^{n}(wx_i+b-y_i)^2$$

每条样本都会贡献一份梯度，再取平均：

$$\begin{aligned} \frac{\partial L}{\partial w} &=\frac2n\sum_{i=1}^{n}(wx_i+b-y_i)x_i\\ \frac{\partial L}{\partial b} &=\frac2n\sum_{i=1}^{n}(wx_i+b-y_i) \end{aligned}$$

从代码角度看，先循环计算预测误差，再分别累加“误差乘输入”和“误差”，最后乘 $2/n$ 就行了。第六章会据此从零训练一条直线。

参数有更多个时，梯度也只是多几个分量。在常用的欧几里得距离下，负梯度给出固定小步长时局部下降最快的方向。理由可以用上一章的点积理解：参数改变量记作 $\Delta\boldsymbol\theta$，损失的一阶近似为：

$$L(\boldsymbol\theta+\Delta\boldsymbol\theta) \approx L(\boldsymbol\theta)+ \nabla L\cdot\Delta\boldsymbol\theta$$

令 $\Delta\boldsymbol\theta=-\eta\nabla L$，近似变化量就是 $-\eta\|\nabla L\|^2$，不会是正数。不过这是局部近似，实际步子太大时，损失仍然可能上升。

如果看这段向量式还有点吃力，先抓住前面两个参数的更新就足够继续阅读。

6. 能不能检查自己有没有求错导

可以把参数往两侧各挪一小步，计算中央差分：

$$f'(w)\approx\frac{f(w+h)-f(w-h)}{2h}$$

它只需要调用原函数，不需要我们手写导数。对于两个参数，就每次只改其中一个，分别检查。

这很适合调试：如果解析梯度与数值梯度差得很远，先检查公式和代码。但 $h$ 也不能无限缩小，浮点数会有舍入误差；太大的 $h$ 又会让局部近似变差。下面用 $10^{-5}$ 演示。

数值差分通常要为每个参数额外计算损失，参数很多时成本很高。后面的自动微分会用链式法则更高效地求梯度；它与“把参数挪一下再算”不是同一种方法。

7. 让程序走几步

脚本只用 Python 标准库，Python 3.9+ 即可运行。可以在仓库根目录执行：

python3 src/examples/gradients.py

也可以下载脚本，在保存目录运行 python3 gradients.py。

"""第 2 章：差商、链式法则与梯度下降，只使用标准库。"""


def loss(w):
    return (w - 3) ** 2


def gradient(w):
    return 2 * (w - 3)


def central_difference(function, x, h=1e-5):
    return (function(x + h) - function(x - h)) / (2 * h)


def descend(rate, steps=10, start=0.0):
    w = start
    history = [(w, loss(w))]
    for _ in range(steps):
        w = w - rate * gradient(w)
        history.append((w, loss(w)))
    return history


def sample_loss(w, b, x=2, y=7):
    return (w * x + b - y) ** 2


def sample_gradient(w, b, x=2, y=7):
    error = w * x + b - y
    return 2 * error * x, 2 * error


def main():
    for h in [1.0, 0.1, 0.01]:
        quotient = ((2 + h) ** 2 - 2 ** 2) / h
        print(f"h={h:g}，平方函数在 2 附近的差商：{quotient:.2f}")
    print(f"L 在 w=0 的数值导数：{central_difference(loss, 0):.4f}")
    for rate in [0.1, 0.5, 0.9, 1.1]:
        w, value = descend(rate)[-1]
        print(f"学习率 {rate:.1f}，10 步后 w={w:.4f}，损失={value:.4f}")

    w, b = 2.0, 0.0
    dw, db = sample_gradient(w, b)
    numeric_dw = central_difference(lambda value: sample_loss(value, b), w)
    numeric_db = central_difference(lambda value: sample_loss(w, value), b)
    print(f"解析梯度：({dw:.4f}, {db:.4f})")
    print(f"数值梯度：({numeric_dw:.4f}, {numeric_db:.4f})")
    # 两个梯度都在旧参数处计算，再同时更新。
    w, b = w - 0.05 * dw, b - 0.05 * db
    print(f"更新后 w={w:.2f}，b={b:.2f}，损失={sample_loss(w, b):.2f}")


if __name__ == "__main__":
    main()

输出为：

h=1，平方函数在 2 附近的差商：5.00
h=0.1，平方函数在 2 附近的差商：4.10
h=0.01，平方函数在 2 附近的差商：4.01
L 在 w=0 的数值导数：-6.0000
学习率 0.1，10 步后 w=2.6779，损失=0.1038
学习率 0.5，10 步后 w=3.0000，损失=0.0000
学习率 0.9，10 步后 w=2.6779，损失=0.1038
学习率 1.1，10 步后 w=-15.5752，损失=345.0384
解析梯度：(-12.0000, -6.0000)
数值梯度：(-12.0000, -6.0000)
更新后 w=2.60，b=0.30，损失=2.25

学习率 0.1 和 0.9 在第 10 步的结果相同，过程却不同。把 descend 返回的每一步都打印出来，会看到前者从左边靠近，后者在两边来回跨越。只看最后一个数字，有时会错过训练过程的重要信息。

我们的例子只有一个低谷。更复杂的损失可能有多个局部最低点，也可能有梯度为零但不是最低点的地方，例如 $w^3$ 在 0 处。梯度很小，只能说明当前位置附近的一阶变化很小，不自动等于“训练已经找到全局最好答案”。

此外，训练损失下降，也不能单独证明新数据上的预测更好。优化解决的是“怎样降低给定目标”，泛化还要靠独立数据来检查。

8. 自测与小实验

1. 对 $f(x)=x^2$，在 $x=3$ 处的导数是多少？用 $h=0.01$ 的前向差商核对。
2. 对 $L(w)=(w-3)^2$，从 $w=5$ 出发，学习率为 0.1，下一步到哪里？损失是多少？
3. 从 0 出发，把学习率改成 1，前两次更新分别到哪里？
4. 在 $x=2,y=7,w=2,b=0$ 处，为什么对 $w$ 的偏导是对 $b$ 偏导的两倍？
5. 把单样本更新学习率从 0.05 改为 0.2，计算更新后的损失。步子大了是否一定更好？
6. 梯度为零，能否保证已经到达全局最低点？训练损失下降，能否保证测试表现改善？

进阶选做：给 sample_loss 增加第二条样本，按本章的 MSE 公式平均损失与梯度。用中央差分分别检查两个偏导，再尝试几种学习率。

下一章概率与随机变量会处理另一件现实中的麻烦事：同样的输入，实际结果为什么仍会波动。导数帮我们调整模型，概率则帮助我们描述不确定性。

如果想慢慢补齐导数的图形直觉，可选读 OpenStax《Calculus Volume 1》的导数定义。其中的极限推导可以分几次阅读，不必一次记完。

概率与随机变量

同样是打印 20 页，今天用了 79 秒，明天用了 83 秒。页数没有变，设备的预热、传输和进纸却可能有细小差别。

上一章帮助我们找到让损失下降的方向。这一章换个问题：面对这些波动，怎样表达“可能发生什么”，又怎样在获得新信息后修正判断？

概率让我们不用在“必然发生”和“绝不会发生”之间二选一。它也能帮我们识别一种常见误解：一个看起来很准的报警器，发出警报后，事情未必就有九成把握。

1. 先把事件说清楚

把“一次任务发生卡纸故障”记作事件 $J$。如果用概率模型描述它发生的可能性，可以写 $P(J)=0.01$。

概率介于 0 和 1 之间。0.01 也就是 1%。在反复进行、条件相似的任务中，我们可以用发生次数除以总次数，得到一个观测到的频率，用来估计这个概率。

概率是模型中的量，频率来自有限次观测。某天 100 次任务没有卡纸，不会自动把原来的 1% 变成“从此不会故障”；可能只是这一天恰巧没有遇到。

如果 $J$ 表示故障，那么 $\neg J$ 表示不故障，它的概率为：

$$P(\neg J)=1-P(J)=0.99$$

这一章的报警率和等待时间分布都由我们设定，供手算和模拟使用，并非真实设备的测量结果。实际估计时，首先要明确记录来自哪些设备、哪些任务、什么时间段。

2. 知道了报警，再问故障概率

给打印机装一个报警器。把“报警”记作事件 $A$，假设它有这样的表现：

• 真正发生故障时，90% 的任务会报警。
• 没有故障时，仍有 5% 的任务会误报。

第一句话写作 $P(A\mid J)=0.9$。竖线读作“在……条件下”，这个式子就是“已知故障时，报警的概率”。

它和 $P(J\mid A)$ 不是同一个问题。后者问的是：现在已经报警，真的故障的概率有多大？

把比例先换成数量

假设故障率为 1%。用一张 10000 次任务的教学表，把这些比例摆在一起：

100 次故障里有 90 次报警；9900 次正常任务里，5% 也就是 495 次误报。于是，585 次报警中只有 90 次属于真正故障：

$$P(J\mid A)=\frac{90}{585}\approx0.1538$$

答案是 15.38%，不是 90%。

图 1：故障本来就少，正常任务中的小比例误报，数量上也可能超过真正故障的报警。图中数量是设定概率的教学展开。

这不是说报警器毫无作用。报警前的故障概率只有 1%，报警后上升到了约 15.38%，信息已经改变了判断。接下来是否停机检查，还取决于漏掉故障和多检查一次各有什么代价。

再把数量写成公式

条件概率可以从交集定义：

$$P(J\mid A)=\frac{P(J\cap A)}{P(A)}$$

$J\cap A$ 表示“故障且报警”，条件事件的概率 $P(A)$ 必须大于 0。

把分子改写为 $P(A\mid J)P(J)$，就得到贝叶斯公式：

$$P(J\mid A)=\frac{P(A\mid J)P(J)}{P(A)}$$

分母中的报警有两条来源：

$$\begin{aligned} P(A) &=P(A\mid J)P(J)\\ &\quad+P(A\mid\neg J)P(\neg J) \end{aligned}$$

原来的 $P(J)$ 叫先验概率，得到报警信息后的 $P(J\mid A)$ 叫后验概率。这些名称描述的是获得这条信息之前和之后的判断，不表示先验只能凭空猜测；它也可能来自既有数据。

如果设备老化，故障率变成 10%，而两种条件报警率保持不变，后验就会变成：

$$\frac{0.9\times0.1} {0.9\times0.1+0.05\times0.9} =\frac23$$

约 66.67%。同一个报警器，面对不同的基础发生率，报警后的含义也会变化。

3. 独立，不等于互不相容

假如知道事件 $B$ 发生，并不改变事件 $A$ 的概率，我们说这两个事件独立。相应地：

$$P(A\cap B)=P(A)P(B)$$

例如，若两次任务的故障独立、故障概率都为 1%，那么两次都故障的概率为 $0.01^2=0.0001$。

这里的“独立”是一个假设，需要根据场景判断。如果同一卷纸受潮，导致相邻任务都容易卡纸，两次故障就可能相关。不能因为记录在两行，就认为它们独立。

互不相容则是另一回事：两个事件不可能同时发生。一次抛硬币的“正面”和“反面”互不相容，但不独立——知道出现正面，反面的概率就变成了 0。

独立性很重要。后面把许多样本的概率相乘、估计均值的不确定性，都需要留意是否作了这样的假设。

4. 随机变量：给可能的结果配上数字

“这一次额外等多久”可以用一个数字来描述。假设额外等待时间 $T$ 只有三种可能：

$T$ 是一个随机变量：它把一次不确定的结果对应到一个数值。表中列出的取值与概率，组成它的概率分布。这些取值互不相容，并且已经覆盖所有可能，所以概率加起来是 1。

这里用大写 $T$ 指尚未确定的随机变量，小写 $t$ 指一个具体取值。这样的记号能提醒我们，“等待时间这个量”和“某次等了 10 秒”不是同一层意思。

平均会等多久

如果大量重复这样的任务，长期平均等待时间会接近各取值按概率加权的和：

$$\mathbb E[T] =0\times0.5+10\times0.3+30\times0.2 =9$$

$\mathbb E[T]$ 叫期望。它不是“最常发生的值”：本例最常发生的是 0 秒，也从来不会恰好等 9 秒，但平均仍可以是 9 秒。

一般的离散变量有取值 $t_1,\ldots,t_k$ 和概率 $p_1,\ldots,p_k$，则：

$$\mathbb E[T]=\sum_{j=1}^{k}p_jt_j$$

只知道平均，还不够

另一个系统每次都固定等 9 秒，与本例的期望相同，体验却很不一样。我们还需要描述结果围绕期望波动得多大。

把偏离期望的距离平方，再按概率平均，得到方差：

$$\operatorname{Var}(T)= \mathbb E[(T-\mathbb E[T])^2]$$

代入本例：

$$\begin{aligned} \operatorname{Var}(T) &=0.5(0-9)^2+0.3(10-9)^2\\ &\quad+0.2(30-9)^2\\ &=129 \end{aligned}$$

单位是秒²。再开平方，得到标准差 $\sqrt{129}\approx11.36$ 秒，单位就回到了秒。

期望描述平均位置，标准差描述波动大小。标准差不是每次偏差的上限，也不意味着每个结果都位于“期望加减一个标准差”之间。要判断某个范围内的概率，还需要知道分布的形状。

5. 认识几种经常出现的分布

不必把所有公式都背下来，先记住它们适合描述什么。

伯努利变量 $Z$ 中，$P(Z=1)=p$，$P(Z=0)=1-p$，所以 $\mathbb E[Z]=p$。如果做 $n$ 次独立、成功概率相同的试验，把结果相加，就得到二项变量 $K$。

恰好有 $k$ 次成功的概率是：

$$P(K=k)=\binom nk p^k(1-p)^{n-k}$$

$\binom nk$ 是高中组合数，表示从 $n$ 个位置中挑出 $k$ 个成功位置的方法数。乘上它，是因为不同的成功排列都会贡献概率。二项变量的期望为 $np$，方差为 $np(1-p)$。

连续变量要看面积

对于均匀分布在 0 到 1 之间的变量，落在 0.2 到 0.5 之间的概率是区间长度 0.3。某一个精确实数点的概率则是 0；实际测量往往保留有限小数，对应的是一个小区间。

连续分布通常用概率密度画出来。区间下的面积才是落入该区间的概率，曲线某一点的高度不是概率。密度可以超过 1，只要整体面积仍为 1 就不矛盾。

正态分布常写作 $T\sim\mathcal N(\mu,\sigma^2)$，意思是它服从均值为 $\mu$、方差为 $\sigma^2$ 的正态分布。$\sigma>0$ 是标准差。它的密度公式是：

$$p(t)=\frac{1}{\sqrt{2\pi}\sigma} \exp\!\left(-\frac{(t-\mu)^2}{2\sigma^2}\right)$$

$\exp(z)$ 就是 $e^z$，其中 $e\approx2.71828$。现在不必推导这个式子，只需认出：$\mu$ 决定曲线的中心，$\sigma$ 决定展开的宽度。第五章还会用它解释平方误差从哪里来。

图 2：图中均值为 0、标准差为 1。着色面积约为 68.3%，这条比例来自正态分布，不能直接套到所有分布上。

正态分布是常用模型，不是“只要有噪声，就一定正态”。等待时间可能偏向一侧，错误记录可能有极端值，是否适合这种近似仍要检查。

6. 让电脑替我们重复试验

当某个计算很复杂时，可以从设定的分布反复采样，用样本平均等量近似我们关心的结果。这类方法通常称为蒙特卡洛方法。

下面从等待时间分布抽 10000 次，比较采样频率与设定概率：

图 3：电脑不是发现了新的等待规律，而是在我们给定的分布下做模拟。

脚本只使用 Python 标准库，Python 3.9 或更高版本即可运行：

python3 src/examples/probability.py

也可以下载脚本，执行 python3 probability.py。

"""第 3 章：教学设定的报警系统与离散等待时间分布。"""

from math import sqrt
from random import Random


WAIT_TIMES = [0, 10, 30]
PROBABILITIES = [0.5, 0.3, 0.2]


def posterior(prior=0.01, sensitivity=0.9, false_alarm=0.05):
    alarm = prior * sensitivity + (1 - prior) * false_alarm
    if alarm == 0:
        raise ValueError("报警事件概率为 0，不能以它为条件")
    return prior * sensitivity / alarm


def moments(values, probabilities):
    mean = sum(x * p for x, p in zip(values, probabilities))
    variance = sum(p * (x - mean) ** 2 for x, p in zip(values, probabilities))
    return mean, variance


def sample_waits(count, seed=2026):
    return Random(seed).choices(WAIT_TIMES, weights=PROBABILITIES, k=count)


def main():
    print(f"故障率 1% 时，报警后的故障概率：{posterior():.2%}")
    print(f"故障率 10% 时，报警后的故障概率：{posterior(0.1):.2%}")
    mean, variance = moments(WAIT_TIMES, PROBABILITIES)
    print(f"等待时间期望：{mean:.2f} 秒")
    print(f"方差：{variance:.2f} 秒²，标准差：{sqrt(variance):.2f} 秒")
    # 各样本量使用同一长序列的前缀，便于观察样本均值。
    samples = sample_waits(10000)
    for count in [10, 100, 10000]:
        print(f"{count} 次采样的平均等待：{sum(samples[:count]) / count:.3f} 秒")
    counts = [samples.count(value) for value in WAIT_TIMES]
    print("10000 次采样的各类频数：", counts)


if __name__ == "__main__":
    main()

本次运行得到：

故障率 1% 时，报警后的故障概率：15.38%
故障率 10% 时，报警后的故障概率：66.67%
等待时间期望：9.00 秒
方差：129.00 秒²，标准差：11.36 秒
10 次采样的平均等待：9.000 秒
100 次采样的平均等待：9.900 秒
10000 次采样的平均等待：8.720 秒
10000 次采样的各类频数： [5122, 2957, 1921]

Random(2026) 创建了固定种子的伪随机生成器，方便在相同环境中重复实验。种子不是“确保结果正确”的开关；换个种子，模拟结果会变化，设定的理论期望仍然是 9 秒。

这个输出还藏着一个好提醒：前 10 次的均值恰好等于 9，前 100 次反而偏离了。样本增多并不保证每一步都更接近期望。对于这里独立同分布、期望存在的采样，样本均值具有大数定律描述的长期趋近性质；一条有限轨迹仍会摇摆。

“独立同分布”简称 IID：各次抽样来自同一个分布，并且相互独立。真实日志里的任务顺序常有相关性，因此不能把模拟中的结论不加检查地照搬过去。

7. 自测与小实验

1. 为什么 $P(A\mid J)=0.9$ 不能直接读成“报警后有 90% 的概率故障”？
2. 保持故障率 1%、故障时报警率 90%，把正常时误报率降到 1%，报警后真的故障的概率是多少？
3. 两次故障概率均为 0.1 且相互独立，两次都故障的概率是多少？如果不独立，还能直接相乘吗？
4. 本章等待时间的期望为什么是 9 秒，而不是最常见的 0 秒？每次固定等 9 秒的系统，方差是多少？
5. 独立重复 10 次、每次成功概率为 0.2，成功次数的期望与方差分别是多少？
6. 连续密度曲线在某点的高度为 2，是否违反“概率不能超过 1”？
7. 修改随机种子，多跑几次。100 次采样的均值是否每次都比 10 次更接近 9？10000 次是否必然恰好等于 9？

进阶选做：对每个样本量重复 100 次采样，画出 100 个样本均值的分布。你会比只盯着一条轨迹，更清楚地看到“样本量增加通常更稳”是什么意思。

下一章统计与实验中的不确定性会沿着这个问题继续走：从有限样本算出的平均值，到底有多可靠？不同实验的结果相差一点，能说明新方法更好吗？

希望系统补充概率基础，可以从 Harvard 的 Statistics 110课程入口寻找教材和视频。先挑条件概率、随机变量和期望的部分阅读即可。

统计与实验中的不确定性

你给打印机换了一种调度方法，平均耗时从 60 秒降到 59 秒。看起来快了一点，可是换个时间再测，旧方法也可能跑到 58 秒。

这一秒到底是改进，还是恰巧遇到了几次比较顺利的任务？

上一章从已知分布出发，计算可能的结果。这一章反过来：我们手上只有有限的观测，希望借它们了解更大的世界。统计方法能帮助我们表达这种推断中的不确定性，也提醒我们别让一个漂亮的小数承担太多结论。

1. 手上的记录，不是整个世界

假设我们关心“同一台设备、相同设置下，20 页文档的打印耗时”。如果可以在目标条件下不断重复任务，所有可能产生的耗时共同构成我们要研究的总体。

实际只做了六次，记录为：

$$56,\ 58,\ 59,\ 61,\ 62,\ 64$$

这六个数是一个样本。为了方便学习，它们是构造的教学数据，不是真实实验。

总体的平均耗时记为 $\mu$，我们通常不知道它；样本的平均耗时则能直接算出：

$$\bar y=\frac{56+58+59+61+62+64}{6}=60$$

$\bar y$ 读作“$y$ 平均”。它是用样本估计总体均值的一种办法。能够算到 60，不等于已经证明总体均值恰好是 60。

先问抽到了什么，再问算得准不准

如果只在机器空闲时记录，却想预测高峰时段的体验，问题首先出在样本代表性。再精细的公式，也不会自动把没有见过的高峰任务补进来。

同样，10000 条记录也可能只来自一台特殊设备，或者包含大量重复副本。数量大，不等于覆盖面广；少报、漏报和选择性收集，都会影响结论。

统计推断始终需要一句背景说明：我们想把结果推广到哪些任务，而这些记录又是怎样来的？

2. 平均值也会随着抽样摇摆

假设确实存在一个总体，均值为 60 秒、标准差为 6 秒，并且耗时服从正态分布。这个设定只用于模拟，让我们知道“真答案”在哪里。

现在每次抽六条记录，算一个平均值；重复 1000 次，就得到 1000 个不同的样本均值。再把每次的样本量改成 60：

图 1：真均值没有变化，变化的是每次抽到的样本。样本量增加后，平均值通常更稳定。

样本均值本身也有一个分布，叫它的抽样分布。这句话不需要神秘的想象：重复抽样，每次算一次平均，再把这些平均值画出来，就是图中的分布。

在独立同分布且方差有限的条件下，若单次结果的总体标准差为 $\sigma$，样本均值的标准差为：

$$\operatorname{SD}(\bar Y)=\frac{\sigma}{\sqrt n}$$

它叫均值的标准误。$n$ 是每次抽到的样本数量。

这意味着，要让标准误大致减半，样本量需要变成四倍，而不是两倍。也意味着：如果记录彼此相关，不能不加检查地套用这个 $1/\sqrt n$ 的缩小规律。

3. 标准差与标准误，名字相像，任务不同

真实项目通常不知道 $\sigma$，于是先从样本估计单次结果的波动。

样本方差常用：

$$s^2=\frac{1}{n-1}\sum_{i=1}^{n}(y_i-\bar y)^2$$

分母是 $n-1$。我们先用同一批数据估计了均值，围绕这个样本均值计算的平方偏差会有偏小倾向；在独立同分布条件下，用 $n-1$ 可以使这里的样本方差成为总体方差的无偏估计。

先记住用途即可，不必立刻证明。它与上一章已知整个分布时计算方差的方式不同，也不是说平方根 $s$ 本身就一定是标准差的无偏估计。

对于六条教学记录，离均值的偏差为 $-4,-2,-1,1,2,4$，平方和为 42，所以：

$$s^2=\frac{42}{5}=8.4,\qquad s\approx2.90$$

据此估计样本均值的标准误：

$$\widehat{\operatorname{SE}}=\frac{s}{\sqrt6}\approx1.18$$

两个数都以秒为单位，却回答不同问题：

增加样本量，通常能让均值估得更稳，却不会自动让打印机每次运行都更稳定。即使我们把平均耗时估得非常准确，某一次任务仍然可能明显偏离它。

4. 与其只给一个点，不如给一段区间

如果这些数据可以看作独立的正态样本，而总体方差未知，可以用 t 区间估计总体均值：

$$\bar y\pm t_{0.975,n-1}\frac{s}{\sqrt n}$$

这表示“以样本均值为中心，向两侧各延伸一个半径”。

$t_{0.975,n-1}$ 来自 t 分布，是用于构造双侧 95% 区间的临界值；0.975 对应左侧累计概率 97.5%，另外 2.5% 留在右尾，左尾也留 2.5%。$n-1$ 称为自由度。

本例 $n=6$，临界值约为 2.571。于是：

$$60\pm2.571\times1.183$$

得到约 [56.96, 63.04] 秒。

这段区间表达的是总体均值的不确定性，不是“未来 95% 的打印任务都在这个范围内”。若想预测一次新任务，还必须把单次任务本身的波动考虑进去，通常会得到更宽的区间。

也不能只因公式能算，就认为条件已经满足。六条数据太少，难以仅靠它们检验分布形状；如果有严重偏斜、极端值或相关性，这个小样本 t 区间的覆盖性质可能不再成立。

95% 到底在说什么

沿用刚才的正态总体模拟，每次抽六条，按相同方法构造区间。把前 30 个画出来：

图 2：每条横线都来自一批新样本。区间在变，作为模拟真值的 60 秒没有变化。

95% 说的是这套构造区间的方法，在相应假设下长期重复使用时的覆盖比例。 大约 95% 的区间会包含固定的真均值，不是说每一批 100 个区间都必须刚好有 95 个覆盖。

在这种频率学解释中，已经算出的区间要么包含真均值，要么不包含；我们不知道是哪一种。不能直接把它解释为“固定真均值有 95% 的概率落在这条已算出的区间内”。若想对未知参数本身建立概率分布，需要另一套明确的建模方式。

名字有些绕，但图能帮我们抓住要点：用重复抽样的方法，衡量一段区间有多经得起反复使用。

5. 两个方法差一点，怎样比较更公平

假设方法 A、B 在同样六个任务上的绝对预测误差如下：

先逐任务比较，再对差值取平均：

$$\bar d=\frac{-1-1-1-1+1-2}{6}\approx-0.833$$

负号表示 B 的平均误差更小。这样成对比较，能利用“两个方法面对的是同一道题”的关系，避免把任务难易不同混进方法差异。

如果各任务独立抽取，且差值可用正态模型描述，就可以把刚才的均值区间应用到差值上。本例得到约 [−1.865, 0.198] 秒。

区间跨过了 0，说明仅凭这六个构造任务和这些假设，还不能把平均改善的方向判断得很稳。它不证明“两个方法完全一样”，更不说明任何改善都不存在；信息也可能只是太少。

反过来，即使区间很窄、明确落在负值一侧，也还要问改善是否值得。平均少 0.001 秒，却要多耗十倍计算资源，未必符合应用目标。统计证据与实际价值，需要一起考虑。

6. 为什么同一段训练代码会跑出不同结果

前面的随机性来自抽样。机器学习实验还可能受到多种因素影响：

• 这次分到训练集的样本不同。
• 参数的随机初值不同。
• 训练中抽到的小批次或样本顺序不同。
• 某些计算实现没有保证完全确定的执行结果。

把种子固定，能帮助定位问题，却不能消除数据本身带来的不确定性。只挑“最好看的那个种子”，也会让报告显得过于乐观。

比较两种方法时，尽量让它们使用相同的数据划分和对应的种子，记录多次结果及波动，再说明这些重复具体改变了什么。固定测试集上的多次训练，只能主要反映训练过程的波动，不能代替重新抽取测试任务带来的不确定性。

同样，把一百条高度相似的任务当作一百个独立证据，也可能低估波动。如果数据按设备、用户或日期成组，评估时就需要考虑这种分组。

第八章会进一步讨论划分和交叉验证。此刻先养成一个习惯：看到“提升了 1%”，同时看看基于多少任务、重复了多少次，以及是否只报告了其中最好的一次。

7. 亲手重复一千次实验

脚本只使用 Python 标准库，Python 3.9+ 即可运行：

python3 src/examples/uncertainty.py

也可以下载脚本，在保存目录运行 python3 uncertainty.py。

"""第 4 章：合成观测的均值区间与重复抽样；只使用标准库。"""

from math import sqrt
from random import Random
from statistics import mean, stdev


OBSERVATIONS = [56, 58, 59, 61, 62, 64]
ERROR_A = [4, 5, 3, 6, 4, 5]
ERROR_B = [3, 4, 2, 5, 5, 3]
T_975_DF5 = 2.570581835636314  # t 分布，自由度 5，97.5% 分位点


def mean_interval_six(values):
    if len(values) != 6:
        raise ValueError("本例的临界值只适用于 6 个独立观测")
    center = mean(values)
    standard_error = stdev(values) / sqrt(6)
    radius = T_975_DF5 * standard_error
    return center, standard_error, center - radius, center + radius


def repeated_samples(size, repeats=1000, seed=2026):
    rng = Random(seed)
    # 人为设定总体为 N(60, 6²)，真实项目通常不知道总体参数。
    return [[rng.gauss(60, 6) for _ in range(size)] for _ in range(repeats)]


def main():
    center, se, low, high = mean_interval_six(OBSERVATIONS)
    print(f"样本均值：{center:.2f} 秒，样本标准差：{stdev(OBSERVATIONS):.2f} 秒")
    print(f"估计标准误：{se:.2f} 秒，95% 均值区间：[{low:.2f}, {high:.2f}]")
    difference = [b - a for a, b in zip(ERROR_A, ERROR_B)]
    center, se, low, high = mean_interval_six(difference)
    print(f"B−A 平均误差差：{center:.3f} 秒，区间：[{low:.3f}, {high:.3f}]")

    samples = repeated_samples(6)
    intervals = [mean_interval_six(row) for row in samples]
    coverage = sum(low <= 60 <= high for _, _, low, high in intervals) / len(intervals)
    print(f"1000 次模拟中，均值区间覆盖 60 秒的比例：{coverage:.1%}")
    for size in [6, 60]:
        averages = [mean(row) for row in repeated_samples(size)]
        print(f"每次抽 {size} 条，1000 个样本均值的标准差：{stdev(averages):.3f} 秒")


if __name__ == "__main__":
    main()

输出为：

样本均值：60.00 秒，样本标准差：2.90 秒
估计标准误：1.18 秒，95% 均值区间：[56.96, 63.04]
B−A 平均误差差：-0.833 秒，区间：[-1.865, 0.198]
1000 次模拟中，均值区间覆盖 60 秒的比例：94.3%
每次抽 6 条，1000 个样本均值的标准差：2.514 秒
每次抽 60 条，1000 个样本均值的标准差：0.771 秒

1000 次中的覆盖比例是 94.3%，没有恰好等于 95%，这并不奇怪：覆盖次数本身也会随机波动。换种子或增加模拟次数，可以继续观察。

最后两行对应图 1：每次多抽一些数据，样本均值的波动明显缩小。理论上的标准误分别是 $6/\sqrt6$ 和 $6/\sqrt{60}$，约为 2.449 和 0.775；有限次模拟得到的标准差会在附近波动。

mean_interval_six 故意只接受六个数，因为代码里写死了自由度为 5 的临界值。把样本量换成 60 时，不能继续偷偷用同一个临界值。正式分析可以使用统计库计算相应分位点；这里保留这个限制，是为了让每一步的条件都看得见。

在相同 Python 环境与种子下，模拟可以重复。即使某些小数因环境变化不同，均值区间的手算结果和统计解释也应一致。

8. 自测与小实验

1. 10000 条日志都来自同一台设备的空闲时段，能否直接用来说明所有设备在高峰时的表现？
2. 单次结果的标准差约为 8 秒，若 64 条观测独立同分布，均值标准误约为多少？要让它减半，需要多少条？
3. 均值的 95% 置信区间为 [57,63]，能否说“未来 95% 的任务会落在这里”？
4. 同样构造 100 次 95% 区间，是否必须恰好有 95 次覆盖真均值？
5. 为什么比较模型时，应尽量让 A、B 预测同一批任务，再看成对差值？
6. 固定同一个测试集，改变训练种子跑 20 次，就已经测到了测试集抽样的不确定性吗？
7. 把 repeated_samples 的种子换掉，区间覆盖率会怎样？把均值从 60 改成 80 时，还应该用 60 作为覆盖检查目标吗？

进阶选做：把模拟中的独立采样改成“每六条共同增加一个随机偏移”。想想这些观测为何不再独立，再观察仍套用原区间公式时，覆盖率发生什么变化。

下一章从概率到学习目标会把这些数学工具接回训练：为什么平方误差、对数和交叉熵会成为常用目标？

有关均值置信区间的条件与公式，可对照 NIST 的均值置信区间说明。阅读时尤其留意它区分的样本条件和适用范围。

从概率到学习目标

前几章已经准备好了三件工具：用函数描述预测，用导数调整参数，用概率描述不确定性。现在把它们接起来。

训练前，我们必须告诉程序什么叫“更好”。预测耗时时，导读用了平方误差；预测一件事会不会发生时，机器学习代码却经常出现对数和交叉熵。

这些目标是随意挑的吗？这一章从一个很小的概率模型出发，看看它们怎样自然地出现。最后，再用一条直线做一次完整的数学篇实践。

1. 哪个概率更能解释已经看到的数据

假设我们记录了十次“任务是否在约定时间内完成”：7 次完成，记作 1；3 次没完成，记作 0。暂时不考虑文档之间的差别，假设每次独立，按时完成的概率都是 $p$。

候选模型说 $p=0.2$、$0.5$ 或 $0.7$，哪一个更符合这十条记录？

对于一串已经观察到的标签，在这个独立伯努利模型下，它的概率为：

$$\mathcal L(p)=p^7(1-p)^3$$

$\mathcal L$ 叫似然。这里把数据固定下来，让候选参数 $p$ 变化，比较哪种参数让这份数据出现得更合理。

注意，我们关心的是这串具体的标签。如果只问“十次中恰好有七次成功，不管顺序”，还要乘组合数 $\binom{10}{7}$。不过这个因子与 $p$ 无关，不会改变哪一个候选 $p$ 最好。

这也不是在求“参数 $p$ 本身的概率”。似然描述数据在给定参数下的概率或密度；若要求参数的后验分布，还需要像第三章那样明确先验等条件。

2. 为什么大家喜欢取对数

样本一多，许多小概率连乘，结果会小得难以表示。假如 1000 个因子都为 0.1，乘积就是 $10^{-1000}$，常见的浮点数已经无法正常保存它。

对数能把乘法变成加法：

$$\log(ab)=\log a+\log b$$

本章的 $\log$ 都指自然对数，也写作 $\ln$，底数为 $e$。它在正数范围内严格递增，因此一个似然比另一个大，取对数后大小顺序仍然不变。

于是：

$$\log\mathcal L(p)=7\log p+3\log(1-p)$$

我们习惯把训练写成“最小化损失”，再加一个负号，就得到负对数似然，英文缩写 NLL：

$$L(p)=-7\log p-3\log(1-p)$$

最大化似然与最小化负对数似然，会选出相同参数。把它再除以样本数 10，也不改变本次优化的最优位置，只是让不同规模的数据集更容易比较平均损失。

图 1：候选概率过低或过高，都不能很好解释这份同时含有 0 和 1 的数据。

如果想用上一章学到的导数检查，利用 $(\log p)'=1/p$，可以得到：

$$L'(p)=-\frac7p+\frac3{1-p}$$

令它等于 0，整理后就是 $10p=7$，所以 $\hat p=0.7$。在 $0<p<1$ 内，这里的二阶导数为正，因此这个驻点确实是最低点。也可以直接看曲线或用网格搜索核对，不必现在就熟悉二阶导数。

这种让已观测数据的似然最大的参数估计，叫最大似然估计。得到 0.7，并不保证未来任务的真实概率恰好是 0.7：样本很少，模型的独立与同概率假设也可能不适合实际情况。

3. 从一个共同概率，到每条样本自己的预测

刚才所有任务共用一个 $p$。更实用的模型会根据输入 $x_i$，给第 $i$ 条任务预测一个概率 $q_i$。

令标签 $y_i$ 为 0 或 1，单条样本的概率可以统一写为：

$$P(y_i\mid x_i)=q_i^{y_i}(1-q_i)^{1-y_i}$$