数学之美 on 方糖猫Blog

从余弦定理到 TikTok：一个用户的推荐流是怎么被算出来的

Thu, 22 Oct 2026 23:10:00 +0800

从余弦定理到 TikTok：一个用户的推荐流是怎么被算出来的

上一篇《千人千面 + 无限瀑布流：推荐 Feed 的完整实现架构》把推荐系统的骨架拆完了：离线、近线、在线三层分工，召回、粗排、精排、重排四层漏斗。但通篇是框图和分工表，读完知道"系统长什么样"，却未必有体感——我的数据，到底是怎么变成我刷到的这一屏的？

这篇换个讲法：造一个用户，给他一晚上的真实行为，跟着他走完全程。线索有三条，正好串起三十年：

吴军 2006 年起在 Google 黑板报连载、2012 年成书的《数学之美》——推荐算法的数学原点；
Netflix 2013 年公开的离线/近线/在线三层实践——工程化的起点（上一篇的主线）；
TikTok 2020 年官方披露的 For You 推荐信号，和字节跳动 2022 年发表的 Monolith 在线训练系统——这套东西被推到的工程极致。

数学的原点：《数学之美》的两章

《数学之美》第 14 章"余弦定理和新闻的分类"讲了一个漂亮的化归：给新闻里每个实词算出 TF-IDF 值，按词汇表位置排成一个向量，一篇新闻就变成了一个特征向量；“新闻分类"这个看似需要理解语义的问题，变成了在向量空间里算余弦相似度的几何问题。第 15 章"矩阵运算和文本处理中的两个分类问题"接着讲：成千上万篇新闻构成的大矩阵，可以用 SVD（奇异值分解）一次拆开，分类在分解后的小矩阵上完成。

推荐系统是同一套数学，换了一张矩阵：把"新闻 × 词汇"换成"用户 × 内容”。余弦相似度回答的问题，从"两篇新闻像不像"变成"这个用户的口味和这条内容像不像"；SVD 分解的那张大矩阵，就是后来协同过滤要分解的用户-物品交互矩阵。

别急着说这是类比——直接手算一遍。假设全站内容只有四个类目：宠物、科技、健身、汽车。用户的口味表示成一个 4 维向量，每个分量是他在该类目上累计的行为强度。

造一个用户：U10086 的一晚

主角 U10086，昨晚刷了一小时短视频，留下这些行为：

时间	行为	内容	类目
22:10	完播	A123「橘猫拆家」	宠物
22:13	点赞	B456「居家哑铃训练」	健身
22:15	1.2 秒划走	C789「新能源车测评」	汽车
22:18	停留 8 秒	D012「AI 编程工具实测」	科技

这些行为不会直接变成画像——中间隔着一层关键设计：内容的类目不是作者上传时选的，是平台算出来的。

内容的标签不是作者标的，是算出来的

一个常见误解：视频的类目来自作者上传时勾选的分区。在 TikTok 这个量级的平台上不是这样。作者自选标签噪声大，还挡不住"标签作弊"——挂个热门标签蹭流量。真实做法是内容理解管道：视频上传后先过一遍机器理解——抽帧做图像分类和目标检测、ASR 把语音转成文字、OCR 读画面上的字、NLP 分析标题和文案——最后由模型产出类目、标签和 embedding 向量。作者的 caption 和 hashtag 只是输入信号之一，没有最终决定权。TikTok 官方披露的三类信号里，“内容信息”（captions、sounds、hashtags）就是这条管道的产物：内容进流量池之前，“这条视频是关于什么的"已由机器定好。

甚至播放之后还在算。前面提到的 item2vec，训练数据就是全站用户的观看行为——被同一批人看完的内容，向量天然相近。也就是说，内容的向量随每一次播放被持续校准，而不是发布那一刻就定格。

用户向量是内容向量的累计

所以系统手里 U10086 的口味画像——宠物 0.55、科技 0.25、健身 0.15、汽车 0.05，即向量 $u = (0.55, 0.25, 0.15, 0.05)$——不是他填的问卷，也不是对人工类目的简单计数，而是他过去几个月每次行为对应的机器内容向量，按行为强度加权累计出来的。两边都是算出来的：内容侧机器识别，用户侧行为聚合。

这个设计值两个好处：

准：作者标错、乱标的类目污染不了画像，用户向量锚定在内容的真实特征上——他看完的是一只真猫，不是一个挂着"萌宠"标签的广告；
细：4 个类目只是教学简化，底下是几百维的 embedding，“橘猫"和"布偶猫"这种类目装不下的区分，向量装得下。

他今晚每一次播放、点赞，都会乘上那条内容的机器向量、计入自己的向量——这正是后面"短期兴趣向量"一节的微观机制。

今晚候选池里有三条内容（向量都出自内容理解管道）：猫视频 $v_1 = (0.9, 0.1, 0, 0)$，哑铃教学 $v_2 = (0.05, 0.1, 0.8, 0.05)$，汽车测评 $v_3 = (0, 0.05, 0, 0.95)$。

余弦相似度的公式就一行：

$$\cos(u, v) = \frac{u \cdot v}{|u||v|}$$

给猫视频算一次：分子是点积 $0.55 \times 0.9 + 0.25 \times 0.1 = 0.52$；分母是两个向量的模长之积 $\sqrt{0.39} \times \sqrt{0.82} \approx 0.565$。结果是 $0.52 / 0.565 \approx 0.92$。三条候选全算完：

候选	余弦相似度
猫视频 $v_1$	0.92
哑铃教学 $v_2$	0.35
汽车测评 $v_3$	0.10

**这就是"推荐"在最原始形态下的全部：一次点积，一次归一化。**今天 TikTok 的排序模型参数量以百亿计，打分函数的内核仍然是这个动作——只是向量从 4 维人工统计变成几百维神经网络学出来的 embedding（item2vec，2016；双塔模型），从"类目"粒度细化到"每条内容"粒度。三十年里数学没有换，换的是向量的生产方式和计算规模。

行为怎么变成画像：Netflix 的三层分工

4 维向量是教学模型，真实系统里的用户向量没法靠人工统计类目得到——内容有几亿条，行为有几十种。工程上的解法就是上一篇展开讲过的 Netflix 三层分工，以及它背后的一整套大数据栈：用户的每一次曝光、点击、停留，客户端上报后先进 Kafka（事件总线）；一份实时流进 Flink 作业，秒级滚动更新短期画像；同时全量落盘到 HDFS（Hadoop 生态的分布式存储），由 Hive（或 Iceberg）建成离线数仓。离线层的 Spark 批任务（天级）从数仓读数据，算物品向量、itemCF 共现矩阵、用户长期兴趣向量；在线层只做查表和轻量推理，画像和榜单都躺在 Redis 里。重活在用户到来之前全部干完。

问题是：一次"完播"和一次"秒划走”，该给短期画像各贡献多少？这个强弱排序不是工程师拍脑袋——TikTok 官方给过答案。

2020 年 6 月 18 日，TikTok 在官方 newsroom 发表 “How TikTok recommends videos #ForYou”，是平台方罕见的一次坦白。它把推荐信号分成三类：

用户交互：点赞、分享、关注、评论、发布的内容、看完的视频；
内容信息：标题文案、声音、话题标签；
设备与账号设置：语言、国家、设备类型——官方明说这类权重更低，因为"用户没有主动把这些表达为偏好”。

更重要的是官方对信号强度的排序：原话是"用户是否把一个较长的视频从头看到尾"这类强兴趣指标，权重远大于"观众和创作者是否在同一国家"这类弱指标。翻译成 U10086 的表格：他完播猫视频这件事的权重，压过他的手机和品牌方在同一城市。

这套强弱排序落到工程上，就是近线层滚动更新的短期兴趣向量——最近 N 次行为对应的物品向量做加权平均：

$$u_{short} = \frac{\sum_{i} w_i \cdot e^{-\Delta t_i / \tau} \cdot v_i}{\sum_{i} w_i \cdot e^{-\Delta t_i / \tau}}$$

权重 $w_i$ 沿行为强度排：完播 3.0、点赞 2.0、停留 5 秒以上 1.5、点击 1.0、秒划走 -0.5（负反馈反向拉）；指数项是时间衰减，越久的行为影响越小。代入 U10086 的一晚：猫视频向量乘 3.0 主导方向，汽车视频乘 -0.5 往反方向拽。他昨晚的每一个动作，在他下次下拉之前，就已经被压缩成这个向量躺在 Redis 里了。

把公式拆开：每个符号是什么

$i$：遍历用户最近 N 次行为的下标。N 常见取 50-200，只保留最近一小段——太久之前的行为对"今晚想看什么"没有预测力；
$v_i$：第 i 次行为涉及的内容向量——就是上一节内容理解管道算出来的那条视频的向量。注意它是物品的向量，不是用户的；用户向量正是由一堆物品向量合成的；
$w_i$：这次行为的强度权重（完播 3.0、点赞 2.0、停留 1.5、点击 1.0、秒划 -0.5），回答"这个动作多能代表他的兴趣"；
$\Delta t_i$：这次行为距今的时间差；
$\tau$：时间衰减常数，控制"多久之前的行为算老"。$\tau$ 取 12 小时，则 12 小时前的行为权重衰减到 $e^{-1} \approx 0.37$，一天前只剩 0.14；
$e^{-\Delta t_i / \tau}$：指数时间衰减因子，越久的行为对当前兴趣越没有发言权；
分母：归一化项。没有它，刷得多的人向量模长就大，“勤奋"会冒充"兴趣浓”；除一下只留方向，不带数量。

一句话：短期兴趣 = 最近看过的内容的向量，按"行为多重 × 时间多近"加权平均。

演算：U10086 的短期向量

把内容向量代入他昨晚的四次行为。$\tau$ 取 0.5 小时，站在 22:30 这一刻计算（D012 的内容向量是 (0.05, 0.85, 0.05, 0.05)，科技向）：

行为	内容向量 $v_i$	强度 $w_i$	距今 $\Delta t_i$	衰减 $e^{-\Delta t_i / \tau}$	有效权重 $w_i \cdot e^{-\Delta t_i / \tau}$
完播猫视频	(0.9, 0.1, 0, 0)	3.0	20 分钟	0.51	1.54
点赞哑铃	(0.05, 0.1, 0.8, 0.05)	2.0	17 分钟	0.57	1.13
秒划汽车	(0, 0.05, 0, 0.95)	-0.5	15 分钟	0.61	-0.30
停留 AI 工具	(0.05, 0.85, 0.05, 0.05)	1.5	12 分钟	0.67	1.01

分子是四个"有效权重 × 内容向量"之和，这里的算术只有两步：标量乘向量、向量相加。全部展开（保留三位小数）：

第一步，标量乘向量——每条内容向量逐分量乘上自己的有效权重：

          有效权重 × 内容向量                =  加权后的向量
猫视频     1.54 × (0.9,  0.1,  0,    0)     = ( 1.386,  0.154,  0,      0)
哑铃       1.13 × (0.05, 0.1,  0.8,  0.05)  = ( 0.057,  0.114,  0.904,  0.057)
汽车      -0.30 × (0,    0.05, 0,    0.95)  = ( 0,     -0.015,  0,     -0.285)
AI工具     1.01 × (0.05, 0.85, 0.05, 0.05)  = ( 0.050,  0.854,  0.050,  0.050)

第二步，逐分量相加——四个向量的同一列相加，每一列就是一个类目方向：

宠物分量： 1.386 + 0.057 + 0      + 0.050 =  1.49
科技分量： 0.154 + 0.114 - 0.015  + 0.854 =  1.11
健身分量： 0     + 0.904 + 0      + 0.050 =  0.96
汽车分量： 0     + 0.057 - 0.285  + 0.050 = -0.18

分子向量就是 (1.49, 1.11, 0.96, -0.18)；分母是有效权重之和 1.54 + 1.13 - 0.30 + 1.01 = 3.38。最后逐分量相除：1.49 / 3.38 ≈ 0.44，1.11 / 3.38 ≈ 0.33，0.96 / 3.38 ≈ 0.28，-0.18 / 3.38 ≈ -0.05。得到：

$$u_{short} \approx (0.44, 0.33, 0.28, -0.05)$$

从第二步的列里能直接读出故事：宠物分量的九成来自那条完播的猫视频（1.49 里它独占 1.386）；汽车这一列，哑铃和 AI 工具带来的两个正贡献（0.057 + 0.050）加起来也抵不过一次秒划的 -0.285——负权重的意义就在这里：他不喜欢的内容在向量里留下的不是零，而是负坐标，检索时会把相似内容往反方向推。

对比他的长期画像 $(0.55, 0.25, 0.15, 0.05)$：一小时的行为已经把科技顶到第二位、健身翻了倍、汽车打成负值。在线服务一般把长短期两个向量融合（拼接或加权和）作为最终用户向量——长期画像管"他是个什么人"，短期向量管"他今晚想看什么"。下一刷召回时，猫和科技内容能同时被捞回来，靠的就是这个融合向量。

TikTok 把闭环推到极致

官方确认的，和官方从没确认的

除了信号分类，TikTok 那篇文章还有一句关键坦白：粉丝数和账号历史爆款都不是直接推荐因素（原话：neither follower count nor previous high-performing videos are direct factors）。这解释了新账号为什么也能出爆款——内容进场不看出身。

中文互联网流传的"流量池"机制要在这里说清边界：新视频先给 200-500 次曝光的小池子，完播率、互动率跑赢同期内容就推进千级、万级的更大池子，逐级叠加放量——这套具体说法出自运营圈的逆向总结，TikTok 和抖音官方从未确认过细节。但它的方向和官方披露自洽：既然粉丝数不算直接因素，新内容就必须有一个"不看出身、先看小范围真实反馈"的冷启动机制，流量池只是这个必然性的具体形态。

flowchart TD
    A["新视频发布<br/>初始小流量池 数百次曝光"] --> B{"完播率 互动率<br/>跑赢同期内容?"}
    B -- "达标" --> C["二级流量池<br/>千级曝光"]
    B -- "不达标" --> D["停止放量<br/>转入自然长尾"]
    C --> E{"数据继续跑赢?"}
    E -- "达标" --> F["更大流量池<br/>万级到百万级"]
    E -- "不达标" --> D

（图为第三方运营经验的通行描述，非官方口径。）

Monolith：连模型本身都在线学习

Netflix 的三层架构里，模型参数是离线训练的，近线只更新特征和画像。字节跳动 2022 年发表的 Monolith（RecSys ‘22，arXiv:2209.07663）把这条边界也打掉了：推荐模型在线训练——行为事件实时变成训练样本回流，模型参数近实时更新。

工程难点在 embedding 表。在线场景下新内容源源不断涌进来，传统哈希表会发生碰撞：两条不同的内容被映射到同一份 embedding，互相污染。Monolith 用 cuckoo hashing 实现无碰撞的 embedding 表，再配合特征过期和低频过滤控制内存，硬是把"在线深度学习"做成了生产级系统。

对比一下闭环速度：Netflix 2013 年的近线层，“行为 → 画像生效"做到秒级已经是当时的极致；Monolith 把"行为 → 模型参数更新"也压到了近实时。闭环速度，就是推荐系统的军备竞赛指标。

跟着 U10086 走一遍四层漏斗

铺垫完了，现在让 U10086 在 23:05 下拉刷新，跟他的数据走完全程。四层漏斗的原理上一篇讲过，这篇只看一件事：每一步的数据长什么样。

召回：1 亿 → 8000

输入：短期兴趣向量 $u_{short}$、最近行为物品列表 [A123, B456, D012]、长期画像。

多路并行，每一路都是查表或检索，没有任何矩阵运算：

召回路	动作	产出
itemCF 协同过滤	Redis 批量查 A123、B456、D012 各自的相似物品 Top50（相似度矩阵是 Spark 离线算好的共现余弦）	约 3000 条，大量猫、健身、科技内容
向量召回	$u_{short}$ 在 Faiss（HNSW 索引）里做近似最近邻检索，几毫秒返回	3000 条
热门榜	直接读 Redis 里 Flink 滚动窗口算好的全站热榜	1000 条
标签/关键词召回	内容元数据（标题、标签、类目）灌在 Elasticsearch 的倒排索引里，拿画像里的高权重标签当查询条件去检索——「搜推一体」里 ES 干的就是这路	约 500 条
新内容池 + 关注产出 + 探索流量	读离线、近线备好的榜单	各几百条

输出：多路合并、去重、按路配额截断——8000 条候选 ID 的列表，每条只带召回来源和粗分。注意一个细节：没有一路会拿 C789（秒划走的汽车视频）当种子去查相似内容，汽车类在召回阶段就已经天然稀疏了。

粗排：8000 → 1000

输入：8000 条候选 + 一批"便宜特征”——从特征存储（Feast 或自研 Feature Store，底层通常是 Redis）批量读出物品热度分、质量分、该用户的类目偏好分、历史 CTR。

计算：轻量模型打分（简化双塔就是一次向量点积，GBDT 就是几千次小树遍历——XGBoost / LightGBM），单条成本压到微秒级。

输出：每条一个粗排分，截断 Top 1000：

cat_video_8891   (A123 的相似内容)   0.81   ← 和短期向量点积极高
ai_tool_3302     (D012 的相似内容)   0.74
hot_funny_1102   (热门榜兜底)        0.62
car_review_5567                      0.05   ← 秒划负反馈直接压死

精排：1000 → 200

输入：1000 条候选 + 全量特征拼接——用户画像（Redis KV 读出）、物品特征、近线实时特征（最近一小时的点击序列，Flink 产出）、实时上下文（23:05、手机、WiFi）。

计算：深度排序模型（DIN 系，阿里 2018 年 KDD 发表）在推理服务（TF Serving 或 NVIDIA Triton，GPU 批量矩阵乘）上跑推理。DIN 的注意力机制值得演算一步：给候选 cat_video_8891 打分时，模型给 U10086 的历史行为分配权重——同为猫视频的 A123 权重拉到最高，B456 次之，C789 趋近于零，输出高 pCTR；而给 car_review_5567 打分时，被注意机制激活的恰恰是 C789——方向是负的。同一个用户的历史，在不同候选面前讲出不同的故事，这是 DIN 相比"死板的平均历史向量"的本质进步。

输出：每条候选一对预测值 (pCTR, 预估观看时长），加权成综合分后排序，截断 Top 200。

重排：200 → 20

输入：200 条带精排分的列表。这一层几乎不算模型，全是规则：

已曝光过滤：查 Redis 里 user:10086:seen 集合（或布隆过滤器），剔除本次 session 已刷过的 15 条；
负反馈硬屏蔽：汽车类目整体降权——秒划走加历史"不感兴趣"记录；
多样性打散：同作者最多 2 条、相邻 3 条不同类目——Top 200 里连着的 8 条猫视频被打散重插；
混排：第 4 位插入广告（广告单独按 eCPM = 出价 × 预估点击率排序选出），第 9 位插一条关注博主的更新；
业务护栏：过滤审核中内容，新内容扶持配额 5%——这就是流量池机制落在自然流量里的那一小块。

输出：

{
  "items": ["...20 条：16 条自然内容 + 2 条广告 + 1 条关注更新 + 1 条新内容扶持..."],
  "next_cursor": "eyJscCI6MC44MSwiYmF0Y2giOiJUYjI5..."
}

游标里封着最后一条的排序分、本次批次号、过期时间，客户端不许解析。同时这 20 条写入已曝光集合，曝光和后续行为事件经 Kafka 回流——闭环合上，U10086 的下一刷已经在被这一刷改写。

沿途的三方件总表

位置	工具	角色
事件总线	Kafka	行为事件解耦、削峰、可回放
数据底座	Hadoop（HDFS）+ Hive / Iceberg	全量行为日志落盘，离线数仓
离线计算	Spark	模型训练、itemCF 共现矩阵、物品向量
近线计算	Flink	秒级更新短期画像、滚动热榜
在线训练	Monolith（字节自研，论文开源）	模型参数近实时更新
在线 KV	Redis（或 HBase）	画像、榜单、已曝光集合、itemCF 结果
向量检索	Faiss / HNSWlib / Milvus	双塔向量的近似最近邻召回
倒排索引	Elasticsearch	标签/关键词召回路，「搜推一体」的内容检索
特征平台	Feast 或自研 Feature Store	离线、在线特征一致性
模型推理	TF Serving / NVIDIA Triton	精排批量打分
轻量模型	XGBoost / LightGBM	粗排
辅助	布隆过滤器、规则引擎	已曝光去重、重排策略

这套链路怎么扛住高并发

漏斗走完了，但还有一个工程问题没回答：几十毫秒的延迟预算，乘以几十万的并发请求，靠什么扛？先把账算出来。假设 1 亿日活、人均 50 次下拉：平均约 6 万次请求/秒，晚高峰按 3-5 倍算是 20-30 万 QPS。每次下拉背后是几十上百次 KV 读取、一次向量检索、一次千级候选的模型推理。能扛住靠的不是某台快机器，是一组选型决策：

Redis：O(1) 查表 + 批量读。 单实例简单 GET 是十万级 QPS、亚毫秒延迟；一次召回要查几十上百个 key（itemCF 种子物品、画像、热榜），用 mget 合并成一次网络往返，QPS 压力直接降一个量级；集群模式水平分片，容量不够就加分片。已曝光集合的布隆过滤器也放在这里。

向量检索：这是召回里唯一真正"算"的地方，也是选型的重点。 几个主流方案的性能画像（百万到十亿级向量、TopK 检索）：

方案	形态	性能画像	适用场景
Faiss（Meta）	嵌入服务进程内的库	没有网络和序列化开销；IVF+PQ 量化后单机可扛亿级向量，检索毫秒级	召回服务内嵌，延迟敏感场景的主力
HNSWlib	嵌入库	图索引召回率高（95% 以上），代价是全量向量驻内存，内存开销大	中等规模、高精度
ScaNN（Google）	嵌入库	各向异性量化，同等召回率下 QPS 领先	内嵌、高 QPS
Milvus	独立分布式服务	存算分离、支持 GPU 索引，十亿级横向扩展	多业务共享的向量中台
Elasticsearch kNN	搜索引擎插件	复用现有 ES 集群，开箱即用，但 QPS 和召回率都不及专用索引	小规模、搜推一体

工程上的关键判断：召回的向量检索优先用内嵌库（Faiss / HNSWlib），省掉一次 RPC——30 万 QPS 面前，每次网络往返都是命。Milvus 这类独立服务的价值在多团队共享、在线扩缩容和统一的向量管理，不在单点延迟。内容池上到十亿级，靠 PQ 量化把每条向量从几百字节浮点压成几十字节编码，再加分片。

Kafka：百万级消息/秒是常态负载。 曝光点击的洪峰对它来说不算事；真正要设计的是分区数（决定下游消费者的并行上限）和消费滞后监控——滞后就是"画像生效延迟"，直接等于用户体感。

Flink：状态在本地的流计算。 短期画像的滚动更新是 keyed state，状态读写走本地 RocksDB，不回远程存储——这是近线层敢吞全量事件流的原因。反过来说，一旦作业挂掉从 checkpoint 恢复，RocksDB 状态的加载时间就是画像的"失明时间"，所以 checkpoint 间隔要按业务能容忍的失明时长来定。

GPU 推理：批量摊薄。 精排把 1000 条候选拼成一个大 batch 一次过 GPU，摊到每条只有几微秒；Triton 的动态批处理（dynamic batching）会在毫秒级窗口里把多个请求的 batch 攒起来再推理，用一点点延迟换几倍吞吐——这是"几十毫秒预算"能成立的关键手法之一。

共同的模式只有一条：所有重活提前算完存起来，在线路径上只剩内存级查询和批量推理——30 万 QPS 里，没有一个请求需要"现场思考"。

收尾：数学没变，闭环变快

走完全程回头看，三十年里真正变化的不是数学：

2006 年，吴军讲余弦定理给新闻分类——打分内核从那时起就是向量点积，今天依然如此；
2013 年，Netflix 定下三层分工——把计算摊到用户到来之前，至今是主流形态；
2020 年，TikTok 官方坦白完播是强信号、粉丝数不是直接因素——行为强度加权第一次有了平台方背书；
2022 年，Monolith 把模型训练本身搬进在线链路——闭环的最后一段延迟也被压缩。

推荐系统真正的军备竞赛，从来不是"谁的公式更巧妙"，而是谁的闭环转得更快：从用户划走一条汽车视频，到系统少推汽车内容，中间隔了几秒还是几天。U10086 今晚的每一次停留和划走都在投票，明早打开 App 时看到的那个"更懂他"的首页，没有一次是当场算出来的——全是昨晚就已开始的计算，刚好在他到来之前完成。

相关阅读：《千人千面 + 无限瀑布流：推荐 Feed 的完整实现架构》——本文的架构视角姊妹篇，讲四层漏斗的原理和无限下拉的分页协议。

参考：吴军《数学之美》（第三版，人民邮电出版社）第 14、15 章；TikTok Newsroom, “How TikTok recommends videos #ForYou”, 2020-06-18（newsroom.tiktok.com/en-us/how-tiktok-recommends-videos-for-you）；Liu et al., “Monolith: Real Time Recommendation System With Collisionless Embedding Table”, RecSys 2022, arXiv:2209.07663；“流量池"分级机制为运营圈第三方经验总结，非官方披露口径。

《数学之美》学习总结：程序员视角下的核心数学知识与工程实践

Tue, 28 Jul 2020 09:00:00 +0800

《数学之美》学习总结：程序员视角下的核心数学知识与工程实践

目标读者：写过代码、对数学有点畏惧、想知道“学这些到底有什么用”的新人。
参考书籍：吴军《数学之美》
阅读目标：建立数学与软件工程之间的直觉连接，避开最常见的学习误区。

0. 写在前面：数学不是应试，而是“降维工具”

很多程序员对数学的印象还停留在大学课堂：公式推导、考试算题、考完就忘。《数学之美》这本书最大的价值，是让我们看到数学在真实工程问题中如何把复杂问题变简单。

比如：

搜索怎么在海量网页里找到最相关的结果？→ 用概率和线性代数。
语音识别怎么把声波变成文字？→ 用概率模型和隐马尔可夫模型。
机器翻译怎么做到“信达雅”？→ 用统计和信息论。
推荐系统怎么猜你喜欢？→ 用矩阵分解。
中文分词怎么切得准？→ 用统计语言模型和动态规划。
数据怎么压缩得更小？→ 用信息论中的熵和哈夫曼编码。

这本书的核心启示：

好的数学模型，能把一个看似需要“理解人类智能”的问题，转化为可以计算、可以优化的工程问题。

下面我从程序员最关心的几大数学分支入手，分别讲清楚它们的作用、典型场景和学习避坑技巧。

1. 线性代数：把“关系”变成“矩阵运算”

1.1 一句话理解线性代数

线性代数研究的是向量、矩阵和它们之间的变换。对程序员来说，它最大的用处是：

把一堆有关系的数字，统一表示成矩阵，然后用高效的矩阵运算一次性处理。

1.2 先修复习：向量、内积与矩阵乘法

如果你从没接触过线性代数，先把这几个概念过一遍，后面所有内容都建立在它们之上。

1. 向量：一组有顺序的数字

向量就是一个排好序的数字列表。比如用一个向量描述一个用户：

[年龄 25, 月消费 300, 活跃天数 12]

位置是有意义的：第 1 位永远是年龄，不能随便换。推荐系统、神经网络里说的“特征向量”，就是这个东西。

2. 内积（点积）：对应位置相乘再相加

两个长度相同的向量，对应位置的数字相乘，再把结果全部加起来，就是内积：

$$ [2, 1] \cdot [3, 4] = 2 \times 3 + 1 \times 4 = 6 + 4 = 10 $$

直觉上，内积衡量“两个方向有多像”：两个向量越是“同向”，内积越大。这就是为什么推荐系统能用它来算“用户口味”和“电影风格”的匹配度（见 1.4 节）。

3. 矩阵：一张二维数字表

矩阵就是一张有行有列的数字表。我们用 $(m \times n)$ 表示它的形状，$m$ 是行数，$n$ 是列数。比如一张 3 个用户 × 4 部电影的评分表，就是一个 $(3 \times 4)$ 的矩阵。

4. 矩阵乘法：左矩阵的行，与右矩阵的列做内积

矩阵 $A$ 乘矩阵 $B$，结果第 $i$ 行第 $j$ 列的元素 = “$A$ 的第 $i$ 行”与“$B$ 的第 $j$ 列”的内积。看一个完整例子，$A$ 是 $(2 \times 3)$，$B$ 是 $(3 \times 2)$：

$$ A = \begin{bmatrix} 1 & 2 & 0 \\ 3 & 1 & 1 \end{bmatrix}, \quad B = \begin{bmatrix} 1 & 2 \\ 0 & 1 \\ 2 & 0 \end{bmatrix} $$

结果 $C = A \times B$ 是一个 $(2 \times 2)$ 矩阵，4 个元素逐个算：

$C_{11}$ = $A$ 第 1 行 · $B$ 第 1 列 = $[1,2,0] \cdot [1,0,2]$ = $1\times1 + 2\times0 + 0\times2 = 1$
$C_{12}$ = $A$ 第 1 行 · $B$ 第 2 列 = $[1,2,0] \cdot [2,1,0]$ = $1\times2 + 2\times1 + 0\times0 = 4$
$C_{21}$ = $A$ 第 2 行 · $B$ 第 1 列 = $[3,1,1] \cdot [1,0,2]$ = $3\times1 + 1\times0 + 1\times2 = 5$
$C_{22}$ = $A$ 第 2 行 · $B$ 第 2 列 = $[3,1,1] \cdot [2,1,0]$ = $3\times2 + 1\times1 + 1\times0 = 7$

$$ C = \begin{bmatrix} 1 & 4 \\ 5 & 7 \end{bmatrix} $$

形状规则：$(m \times k) \cdot (k \times n) = (m \times n)$——左矩阵的列数必须等于右矩阵的行数，这两个相同的 $k$ 会“抵消”掉。

5. 转置：行列互换

转置就是把矩阵“翻个面”，第 $i$ 行变成第 $i$ 列，记作 $A^T$。上面的 $A$ 转置后变成 $(3 \times 2)$：

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

这和后面的工程应用有什么关系？ 推荐系统的矩阵分解，本质就是“用户向量 · 电影向量”的内积；神经网络每一层都是一次矩阵乘法。看懂上面的计算过程，后面公式里的 $u_i^T v_j$、$W\mathbf{x}$ 对你来说就不再是天书。

1.3 核心概念速查

概念	程序员直觉	软件行业用途
向量	一组有顺序的数字	用户特征、词向量、颜色 RGB
矩阵	一张二维表	邻接表、图像像素、权重参数
矩阵乘法	一种“加权组合”	神经网络前向传播、图神经网络
特征值/特征向量	变换中的“不变方向”	PageRank、降维、稳定性分析
转置、逆矩阵	坐标系互换、回推原值	最小二乘法、线性回归求解

1.4 典型场景：推荐系统里的矩阵分解

什么是矩阵分解？ 一句话：把一张大表拆成两张小表的乘积。如果 $R \approx U \times V$，那么 $R$ 里任何一个元素，都可以用“$U$ 的一行”和“$V$ 的一列”做内积还原出来。

为什么评分表是稀疏的？ 假设有 100 万用户、10 万部电影，评分表有 $10^{11}$ 个格子。但每个用户只看过几百部电影，打过分的更少——表里 99% 以上的格子是空的。推荐系统要解决的就是：把这些空格子填上。

一个完整的数字例子。 假设只有 3 个用户、4 部电影，真实评分矩阵 $R$（“?” 表示没看过、需要预测）：

$$ R = \begin{bmatrix} 5 & 4 & ? & 1 \\ ? & 1 & 5 & 4 \\ 5 & ? & ? & ? \end{bmatrix} $$

我们假设每个用户只用 2 个数字就能概括他的“口味”——即 $k=2$ 个隐因子，可以脑补成“动作片程度”和“喜剧片程度”。假如通过训练（方法见下文）得到了：

用户矩阵 $U$（3×2，每行是一个用户的口味向量）：

$$ U = \begin{bmatrix} 1 & 0 \\ 0 & 1 \\ 1 & 1 \end{bmatrix} $$

电影矩阵 $V$（2×4，每列是一部电影的风格向量）：

$$ V = \begin{bmatrix} 5 & 4 & 0 & 1 \\ 0 & 1 & 5 & 4 \end{bmatrix} $$

现在预测“用户 1 会给电影 3 打几分”：取 $U$ 的第 1 行 $[1, 0]$，和 $V$ 的第 3 列 $[0, 5]$，做内积：

$$ \hat{R}_{13} = [1, 0] \cdot [0, 5] = 1 \times 0 + 0 \times 5 = 0 $$

预测 0 分——用户 1 是纯动作片爱好者，电影 3 是纯喜剧片，系统不会推荐它。再看用户 3（口味 $[1, 1]$，什么都看一点）对电影 2：

$$ \hat{R}_{32} = [1, 1] \cdot [4, 1] = 1 \times 4 + 1 \times 1 = 5 $$

预测满分，大胆推荐。你可以顺手验证：已知的评分（比如 $\hat{R}_{11} = [1, 0] \cdot [5, 0] = 5$）也和原表对得上——这正是训练时调整 $U$、$V$ 的目标。

这里的 $k$（本例为 2）就是压缩后的“口味维度”：原来要用 4 个数描述一个用户（每部电影一个分），现在只用 2 个数。真实场景里 $k$ 常取几十到几百。

flowchart LR
    subgraph 原始评分矩阵R
        direction TB
        R1["用户 × 电影<br/>大部分为空"]
    end

    subgraph 分解
        direction TB
        U["用户矩阵 U<br/>用户 × 隐因子"]
        V["电影矩阵 V<br/>隐因子 × 电影"]
    end

    subgraph 预测
        direction TB
        P["补全后的评分矩阵<br/>R ≈ U × V"]
    end

    R1 -->|矩阵分解| U
    U --> V
    V --> P

数学上，我们希望：

$$ R_{m \times n} \approx U_{m \times k} \cdot V_{k \times n} $$

其中每个符号的含义：

$R$：评分矩阵；$m$ 是用户数，$n$ 是电影数；
$U$：用户矩阵，它的第 $i$ 行 $u_i$ 是第 $i$ 个用户的口味向量（$k$ 个数）；
$V$：电影矩阵，它的第 $j$ 列 $v_j$ 是第 $j$ 部电影的风格向量（$k$ 个数）；
$k$：隐因子维度，比如“动作片程度”“喜剧片程度”；
$u_i^T v_j$：$u_i$ 转置后乘 $v_j$，就是上面演示的“行 · 列”内积，即预测的评分。

训练目标是最小化预测评分和真实评分的差距：

$$ \min_{U,V} \sum_{(i,j) \in \text{已知评分}} (R_{ij} - u_i^T v_j)^2 + \lambda (|U|^2 + |V|^2) $$

这行公式的意思是：对所有已知评分 $(i, j)$，让预测值 $u_i^T v_j$ 和真实值 $R_{ij}$ 的差的平方尽量小。最后一项里，$\lambda$（希腊字母 lambda）是一个人为设定的小系数，$|U|^2$ 表示 $U$ 里所有元素的平方和——这一项叫“正则化”，作用是惩罚过大的参数，防止模型死记硬背训练数据（过拟合）。

这就是推荐系统里最经典的协同过滤思路。没有线性代数，这个补全问题根本无法优雅表达和求解。

1.5 典型场景：神经网络里的矩阵乘法

一个全连接层可以写成：

$$ \mathbf{y} = \sigma(W \mathbf{x} + \mathbf{b}) $$

其中：

$\mathbf{x}$ 是输入向量
$W$ 是权重矩阵
$\mathbf{b}$ 是偏置向量
$\sigma$ 是激活函数

flowchart LR
    X["输入向量 x"] -->|"乘以 W"| WX["Wx"]
    B["偏置 b"] -->|"加上"| WX
    WX -->|"激活 σ"| Y["输出向量 y"]

深度学习的训练，本质上就是不断调整 $W$ 和 $\mathbf{b}$，让输出 $y$ 越来越接近期望值。

1.6 线性代数避坑技巧

不要死记公式，先画形状

矩阵乘法能不能做，先看维度。$(m \times k) \times (k \times n) = (m \times n)$，中间维度必须相同。
区分“行向量”和“列向量”

很多 bug 来自默认了错误的形状。写代码时打印 shape 是基本功。
注意矩阵乘法和逐元素乘法的区别
- 矩阵乘法：$A \times B$，满足结合律，用于变换。
- 逐元素乘法（Hadamard）：$A \odot B$，两个矩阵形状完全一样，对应位置相乘。
不要忽视“稀疏矩阵”

推荐系统、图数据中，90% 以上都是 0。用普通稠密矩阵会爆内存，要学 CSR、CSC 等稀疏存储格式。
特征值不是玄学

在 PageRank 里，网页重要性就是某个矩阵的最大特征值对应的特征向量。理解这一点，看很多算法会有豁然开朗的感觉。

2. 微积分：描述“变化”与“优化”

2.1 一句话理解微积分

微积分研究的是变化率和累积量。对程序员来说：

导数告诉你“往哪走”，积分告诉你“走了多远”。机器学习里最常用的就是导数。

2.2 先修复习：导数、偏导、梯度与链式法则

1. 导数：函数在某点的瞬时变化率

函数 $f(x)$ 在某一点的导数，就是曲线在该点的切线斜率——“$x$ 增加一点点，$f(x)$ 会跟着变化多少”。

以 $f(x) = x^2$ 为例，它的导数是 $f’(x) = 2x$（求导规则：$x^n$ 的导数是 $nx^{n-1}$）。在 $x = 3$ 处，$f’(3) = 2 \times 3 = 6$，意思是：在 $x = 3$ 附近，$x$ 每增加一小段，$f(x)$ 大约增加这一段的 6 倍。

验证一下：$x$ 从 3 变成 3.01，$f$ 从 9 变成 $3.01^2 = 9.0601$，增加了 0.0601 ≈ 6 × 0.01。对得上。

2. 偏导数：多变量时，一次只看一个变量

函数有多个变量时，对其中一个求导、把其他变量当常数，就是偏导数，符号用 $\partial$（读作“偏”）。比如 $f(x, y) = x^2 + 3y$：

对 $x$ 求偏导：$\frac{\partial f}{\partial x} = 2x$（把 $3y$ 当常数，常数的导数为 0）
对 $y$ 求偏导：$\frac{\partial f}{\partial y} = 3$（把 $x^2$ 当常数）

3. 梯度：所有偏导数组成的向量

把每个变量的偏导数排成一个向量，就是梯度，记作 $\nabla f$（符号 $\nabla$ 读作 nabla）。上面的例子里 $\nabla f = [2x, 3]$。

梯度有一个关键性质：它指向函数值上升最快的方向。所以要求函数的最小值，就要反着梯度的方向走——这就是 2.4 节梯度下降法的全部原理。

4. 链式法则：复合函数求导，层层相乘

函数套函数（复合函数）的导数，等于各层导数相乘。例子：$z = (2x + 1)^2$。

把它拆成两层：内层 $u = 2x + 1$，外层 $z = u^2$。那么：

内层导数：$\frac{du}{dx} = 2$
外层导数：$\frac{dz}{du} = 2u$

链式法则：$\frac{dz}{dx} = \frac{dz}{du} \times \frac{du}{dx} = 2u \times 2 = 2(2x+1) \times 2 = 8x + 4$

代入 $x = 1$：$\frac{dz}{dx} = 12$。

这和工程应用有什么关系？ 神经网络就是几十层函数套函数，链式法则让“对每一层参数求导”变成一次从后往前的乘法传递——这就是 2.5 节反向传播在做的事。

2.3 核心概念速查

概念	程序员直觉	软件行业用途
导数	函数在某点的变化率	梯度下降、敏感度分析
偏导数	多变量函数中一个变量的变化率	神经网络反向传播
梯度	所有偏导数组成的向量	指向函数增长最快的方向
链式法则	复合函数求导规则	反向传播算法的核心
积分	变化率的累积	概率密度、面积、物理模拟

2.4 典型场景：梯度下降法

几乎所有机器学习训练，最后都在解一个优化问题：

$$ \min_\theta L(\theta) $$

其中 $L$ 是损失函数，$\theta$ 是模型参数。

梯度下降的更新规则：

$$ \theta_{\text{新}} = \theta_{\text{旧}} - \eta \cdot \nabla L(\theta_{\text{旧}}) $$

其中 $\eta$ 是学习率，$\nabla L$ 是梯度。

flowchart TD
    A[初始化参数 θ] --> B[计算当前损失 L]
    B --> C[求梯度 ∇L]
    C --> D{梯度足够小?}
    D -->|否| E[沿负梯度方向更新 θ]
    E --> B
    D -->|是| F[得到近似最优解]

用下山来比喻：你蒙着眼睛站在山坡上，每一步都朝最陡的下降方向走一小步，重复多次就能到达山谷。

2.5 典型场景：反向传播

神经网络的层数很多，直接对每个参数求导非常麻烦。反向传播用链式法则，从输出层往输入层一层一层传误差。

比如一个简单网络：

$$ z = f(y), \quad y = g(x), \quad x = h(w) $$

求 $z$ 对 $w$ 的导数：

$$ \frac{\partial z}{\partial w} = \frac{\partial z}{\partial y} \cdot \frac{\partial y}{\partial x} \cdot \frac{\partial x}{\partial w} $$

flowchart LR
    w["参数 w"] --> x["x = h(w)"]
    x --> y["y = g(x)"]
    y --> z["z = f(y)"]
    z -->|"∂z/∂y"| y
    y -->|"∂y/∂x"| x
    x -->|"∂x/∂w"| w

这就是深度学习的训练能高效进行的原因。链式法则让“百亿（billion）级别参数的求导”变得可行。

2.6 微积分避坑技巧

梯度方向是“上升最快”，要加负号

求最小值时，更新公式里是 $-\eta \nabla L$，不是 $+\eta \nabla L$。符号搞反，损失会越来越大。

学习率太大或太小都是灾难

太大：在最低点附近震荡，甚至发散。
太小：收敛极慢，浪费算力。

flowchart LR
    A[学习率 η 太大] --> B[震荡/不收敛]
    C[学习率 η 太小] --> D[收敛极慢]
    E[学习率 η 合适] --> F[稳定收敛]

不是所有函数都能简单求导

离散函数、不可导函数（如 ReLU 在 0 点）需要特殊处理。ReLU 的导数在 0 点通常直接定义为 0 或 1。
不要手动推导每一层梯度

现代框架（PyTorch、TensorFlow）都有自动微分。先理解原理，再交给框架。但原理不懂，调参就是瞎调。
区分“局部最小”和“全局最小”

梯度下降只能保证找到局部最小。深度学习中，很多局部最小其实差距不大，不必过度纠结。

3. 概率论：处理“不确定性”

3.1 一句话理解概率论

概率论研究的是不确定性。对程序员来说：

当输入有噪声、数据不完整、结果不唯一时，概率论是最自然的建模语言。

3.2 先修复习：概率、条件概率、贝叶斯、期望与方差

1. 概率：0 到 1 之间的数

$P(A)$ 表示事件 $A$ 发生的可能性：0 是不可能，1 是必然，0.5 是五五开。掷一次骰子，掷出 6 的概率 $P(6) = 1/6$。

2. 条件概率：B 已经发生时，A 的概率

$P(A \mid B)$ 读作“在 $B$ 发生的条件下 $A$ 的概率”，竖线右边是已知条件。用一张小表格算一遍：统计 100 封邮件——

	含“免费”	不含“免费”	合计
垃圾邮件	30	10	40
正常邮件	5	55	60
合计	35	65	100

问：一封邮件含“免费”这个词，它是垃圾邮件的概率是多少？

条件概率的算法是：只在符合条件的样本里算比例。含“免费”的共 35 封，其中垃圾邮件 30 封：

$$ P(\text{垃圾} \mid \text{含“免费”}) = \frac{30}{35} \approx 85.7% $$

对比一下：不看任何条件时，$P(\text{垃圾}) = 40/100 = 40%$。“含免费”这个条件把概率从 40% 拉到了 85.7%——这就是 3.4 节垃圾邮件过滤器在做的事。

3. 贝叶斯定理：由结果反推原因

贝叶斯定理：

$$ P(A \mid B) = \frac{P(B \mid A) \cdot P(A)}{P(B)} $$

用经典疾病检测例子算一遍。假设：

某病患病率 $P(\text{患病}) = 1%$
检测准确率 99%：患病者 99% 检出阳性，健康者 99% 检出阴性（即 1% 被误报为阳性）

问：一个人检测为阳性，他真的患病的概率是多少？

直觉会说 99%，但实际算一下。想象 10000 个人：

真患病：$10000 \times 1% = 100$ 人，其中检出阳性 $100 \times 99% = 99$ 人；
健康：9900 人，其中误报阳性 $9900 \times 1% = 99$ 人。

阳性一共 $99 + 99 = 198$ 人，真患病的只有 99 人：

$$ P(\text{患病} \mid \text{阳性}) = \frac{99}{198} = 50% $$

远低于直觉的 99%。 原因是病人基数太小（1%），健康人群的误报凑出了一半的阳性。这就是为什么医学筛查阳性后还要复查，也是贝叶斯定理最反直觉、最实用的一课。

4. 期望：长期平均值

期望 $E(X)$ 是“重复无数次后的平均结果”。掷骰子：

$$ E(X) = 1\times\frac{1}{6} + 2\times\frac{1}{6} + 3\times\frac{1}{6} + 4\times\frac{1}{6} + 5\times\frac{1}{6} + 6\times\frac{1}{6} = \frac{21}{6} = 3.5 $$

骰子永远掷不出 3.5，但掷一万次的平均值会非常接近 3.5。

5. 方差：波动程度

期望相同的两个随机变量，稳定性可能天差地别。方差衡量“结果偏离期望有多远”：每个值减去期望、平方、再平均。比如三个数 1、2、3，期望是 2，方差 $= \frac{(1-2)^2 + (2-2)^2 + (3-2)^2}{3} = \frac{2}{3} \approx 0.67$。方差越大，波动越剧烈。风险评估里“期望收益相同、方差更小”的方案就是更稳的方案。

3.3 核心概念速查

概念	程序员直觉	软件行业用途
概率	某件事发生的可能性	垃圾邮件识别、点击率预测
条件概率	已知某事发生，另一事发生的概率	贝叶斯分类、推荐系统
贝叶斯定理	由结果反推原因	垃圾邮件过滤、医疗诊断
期望	长期平均结果	A/B 测试、收益评估
方差/标准差	结果的波动程度	风险评估、模型稳定性
大数定律	样本越多，估计越准	实验设计、蒙特卡洛模拟
正态分布	最常见的“钟形”分布	误差建模、异常检测

3.4 典型场景：朴素贝叶斯垃圾邮件过滤

假设收到一封邮件，里面出现了“免费”“中奖”“点击”等词。我们想判断它是垃圾邮件的概率：

$$ P(\text{垃圾} \mid \text{词}) = \frac{P(\text{词} \mid \text{垃圾}) \cdot P(\text{垃圾})}{P(\text{词})} $$

其中：

$P(\text{垃圾})$ 是训练集中垃圾邮件的比例
$P(\text{词} \mid \text{垃圾})$ 是垃圾邮件里出现这些词的概率
$P(\text{垃圾} \mid \text{词})$ 是看到这封邮件后它是垃圾邮件的概率

flowchart TD
    A[收集大量邮件] --> B[统计每个词在垃圾/正常邮件中出现的频率]
    B --> C[新邮件到达]
    C --> D[提取关键词]
    D --> E[用贝叶斯公式计算概率]
    E --> F{P > 阈值?}
    F -->|是| G[判定为垃圾邮件]
    F -->|否| H[判定为正常邮件]

这是《数学之美》里非常经典的例子。它把“理解邮件含义”转化成了“统计词频”，这正是概率论的魅力。

3.5 典型场景：语言模型与 N-gram

搜索引擎、输入法、语音识别都要预测“下一个词最可能是什么”。

N-gram 模型假设：下一个词只和前 N-1 个词有关。比如二元模型（bigram）：

$$ P(w_n \mid w_1, w_2, \dots, w_{n-1}) \approx P(w_n \mid w_{n-1}) $$

通过统计语料中词对出现的频率来估计概率：

$$ P(w_n \mid w_{n-1}) = \frac{\text{count}(w_{n-1}, w_n)}{\text{count}(w_{n-1})} $$

flowchart LR
    A["历史词 w_{n-1}"] --> B[统计所有接在后面的词]
    B --> C[计算条件概率]
    C --> D[选择概率最大的词作为预测]

现代大语言模型虽然用神经网络替代了 N-gram，但核心目标没变：最大化下一个词的预测概率。

3.6 概率论避坑技巧

不要把“概率高”等同于“一定发生”

模型说某件事概率 99%，也不代表绝对。工程上永远要留兜底逻辑。
注意“条件概率”的方向

$P(A \mid B)$ 和 $P(B \mid A)$ 完全不一样。看到症状推疾病，和知道疾病推症状，是两回事。
数据稀疏是大问题

没见过的词不能直接算概率为 0，要用平滑技术（如拉普拉斯平滑）。
小心“独立同分布”假设

很多模型假设数据独立同分布（i.i.d.），但真实世界往往不是。时间序列、推荐系统中的用户行为都有相关性。
概率模型需要大量数据

数据量不够时，统计模型效果往往不如规则系统。先用规则跑起来，再逐步引入概率模型。

4. 信息论：量化“信息量”

4.1 一句话理解信息论

信息论研究的是如何度量、传输和压缩信息。对程序员来说：

信息论告诉我们：一个消息有多“意外”，就有多少信息量。

4.2 先修复习：log₂、信息量与熵

1. log₂ 的直觉：猜几次能猜中？

$\log_2 n$ 回答的问题是：“$n$ 个可能性，用二分法猜几次能锁定答案？” 玩猜数字游戏：我心里想一个 1-8 的数，你每次问“比 $x$ 大吗”，3 次一定能猜中（8 → 4 → 2 → 1）。所以 $\log_2 8 = 3$。这和程序员的二分查找是同一回事：在 8 个元素的有序数组里查找，最多比较 3 次。

2. 信息量：越意外，信息量越大

一个事件的信息量定义为 $-\log_2 P$，单位是 bit（比特），$P$ 是这个事件发生的概率。$P$ 越小（越意外），信息量越大：

公平硬币掷出正面：$P = 1/2$，信息量 $= -\log_2 \frac{1}{2} = 1$ bit；
一个概率 $P = 1/8$ 的事件发生：信息量 $= -\log_2 \frac{1}{8} = 3$ bit。

直觉：掷出正面没什么可惊讶的（1 bit 就够记录），8 选 1 猜中则值得多记几笔（3 bit）。

3. 熵：平均信息量

熵 $H(X)$ 是“平均每次能获得多少信息量”：把每种结果的“概率 × 信息量”加起来：

$$ H(X) = -\sum_i P(x_i) \log_2 P(x_i) $$

完整算一遍公平硬币的熵。 两种结果，概率各 1/2：

$$ H = -\left( \tfrac{1}{2} \log_2 \tfrac{1}{2} + \tfrac{1}{2} \log_2 \tfrac{1}{2} \right) = -\left( \tfrac{1}{2} \times (-1) + \tfrac{1}{2} \times (-1) \right) = 1 \text{ bit} $$

再算一枚偏倚硬币（正面 90%、反面 10%，查表或按计算器可得 $\log_2 0.9 \approx -0.152$，$\log_2 0.1 \approx -3.322$）：

$$ H = -\left( 0.9 \times (-0.152) + 0.1 \times (-3.322) \right) = 0.137 + 0.332 \approx 0.47 \text{ bit} $$

偏倚硬币的结果更好猜（大概率是正面），不确定性低，所以熵只有约 0.47 bit，不到公平硬币的一半。熵最大的时候，就是所有结果等可能的时候。

这和工程应用有什么关系？ 熵给出了无损压缩的理论下限（4.4 节），交叉熵则是拿这个“平均信息量”的框架去衡量模型预测和真实标签的差距（4.5 节）。

4.3 核心概念速查

概念	程序员直觉	软件行业用途
信息量	一个事件带来的“惊讶程度”	异常检测、日志告警
熵（Entropy）	不确定性的平均值	决策树、特征选择、压缩
交叉熵	模型分布与真实分布的差距	分类损失函数
KL 散度	两个分布有多“不像”	生成模型、变分推断
互信息	两个变量共享多少信息	特征选择、关联分析

4.4 典型场景：熵与数据压缩

熵描述的是一个随机变量的平均信息量。对于离散随机变量 $X$：

$$ H(X) = -\sum_{i} P(x_i) \log P(x_i) $$

举个例子：

如果某事件必然发生（$P=1$），熵为 0，因为毫无信息量。
如果硬币正反概率各 0.5，熵最大，因为最不确定。

flowchart LR
    A[原始数据] --> B[计算符号频率]
    B --> C[估算熵 H]
    C --> D[设计编码<br/>高频短码、低频长码]
    D --> E[压缩后的数据]

哈夫曼编码就是根据频率构造最优前缀码，让平均编码长度接近熵。ZIP、MP3、JPEG 背后都有信息论的影子。

4.5 典型场景：交叉熵损失函数

分类任务中，模型输出一个概率分布 $\hat{y}$，真实标签是 $y$。交叉熵衡量两者差异：

$$ H(y, \hat{y}) = -\sum_{i} y_i \log \hat{y}_i $$

在二分类中简化为：

$$ L = -\left[ y \log \hat{y} + (1-y) \log(1-\hat{y}) \right] $$

为什么用交叉熵而不是均方误差？

因为交叉熵对“模型很有信心但错了”的情况惩罚更大，能让分类器学得更果断。

4.6 信息论避坑技巧

熵大不一定“信息多”

熵大只代表不确定性高。如果全是噪声，熵也很大，但没有价值。
log 的底数要看场景

信息论里常用以 2 为底（单位 bit），机器学习里常用自然对数（单位 nat）。比较时要注意统一。
交叉熵损失要配合 softmax

多分类时，模型最后一层通常是 softmax + 交叉熵。不要漏了 softmax。
KL 散度不对称

$D_{KL}(P | Q) \neq D_{KL}(Q | P)$。写代码和解释结果时要注意方向。
信息论是“上限”不是“下限”

熵给出的是无损压缩的理论下限。实际压缩算法由于实现复杂度，往往达不到这个下限。

5. 统计学与数据思维：从数据中提炼规律

5.1 一句话理解统计学

概率论是“从模型推数据”，统计学是“从数据推模型”。对程序员来说：

统计学让你知道：手里的数据能告诉我们什么、不能告诉我们什么。

5.2 先修复习：总体与样本、均值、中位数、方差、置信区间

1. 总体 vs 样本

总体是你想研究的全部对象（比如“所有用户”），样本是你实际拿到的一小部分（比如“昨天活跃的一万名用户”）。统计学的全部工作，就是用样本去估计总体，并说清楚这个估计有多靠谱。

2. 均值与中位数：谁更抗揍？

5 个数的小例子：某功能 5 个用户的日使用时长（分钟）——

3, 5, 4, 6, 100

均值：$(3 + 5 + 4 + 6 + 100) \div 5 = 118 \div 5 = 23.6$
中位数：排序后取中间那个。排序为 3, 4, 5, 6, 100，中位数是 5

均值 23.6 被 100 这个极端值（可能是挂机用户）严重拉偏，中位数 5 稳如泰山。看收入、时长这类分布时，中位数往往比均值更诚实。

3. 方差与标准差：波动有多大？

还是用上面 5 个数（均值 23.6）。方差 = 每个数减均值、平方、再平均：

$$ \frac{(3-23.6)^2 + (5-23.6)^2 + (4-23.6)^2 + (6-23.6)^2 + (100-23.6)^2}{5} = \frac{424.36 + 345.96 + 384.16 + 309.76 + 5836.96}{5} = \frac{7301.2}{5} = 1460.24 $$

标准差 = 方差开平方：$\sqrt{1460.24} \approx 38.2$。标准差的好处是单位和原数据一致（分钟），可以直接说“波动大约 ±38 分钟”。

4. 置信区间：估计值 ± 误差范围

单给一个估计值是不负责任的，要带上误差范围。比如“新方案转化率为 5% ± 1%（95% 置信区间）”，意思是真实转化率大概率落在 4% - 6% 之间。区间越窄，估计越可靠；想让区间变窄，就得加大样本量——这就是 5.4 节 A/B 测试背后在算的事。

5.3 核心概念速查

概念	程序员直觉	软件行业用途
采样	从整体中抽一部分观察	A/B 测试、日志抽样
大数定律	样本越多，估计越稳定	实验样本量设计
中心极限定理	样本均值趋向正态分布	置信区间、假设检验
置信区间	估计的不确定性范围	转化率评估
假设检验	判断差异是否显著	实验效果验证
过拟合/欠拟合	模型太复杂或太简单	调参、正则化

5.4 典型场景：A/B 测试

产品改了一个按钮颜色，想知道转化率有没有提升。直接看“实验组转化率 5%，对照组 4%”不够，因为可能是随机波动。

统计学要做的是：

计算两组差异的标准误。
做假设检验，看差异是否显著。
给出置信区间，比如“提升 0.8% - 1.2%”。

flowchart TD
    A[提出假设] --> B[随机分流用户]
    B --> C[收集实验数据]
    C --> D[计算指标与置信区间]
    D --> E{差异是否显著?}
    E -->|是| F[上线新方案]
    E -->|否| G[保持原方案/重新设计]

没有统计学，A/B 测试的结论很容易变成“拍脑袋”。

5.5 典型场景：平滑技术

N-gram 或朴素贝叶斯中，总会遇到训练集中没出现过的词或组合。如果直接算概率为 0，模型就会失效。

拉普拉斯平滑（加一平滑）是最简单的方法：

$$ P(w_n \mid w_{n-1}) = \frac{\text{count}(w_{n-1}, w_n) + 1}{\text{count}(w_{n-1}) + V} $$

其中 $V$ 是词表大小。它给每个未出现事件分配了一个很小的概率。

更高级的平滑方法还有 Good-Turing、Kneser-Ney 等。《数学之美》里强调：数据稀疏是统计自然语言处理的核心难题之一。

5.6 统计学避坑技巧

相关性不等于因果性

两个指标同时上涨，不一定是一个导致另一个。要用实验设计或因果推断方法。
样本量不足时结论不可信

看 100 个用户的实验结果，和看 10 万个用户的实验结果，说服力完全不同。
注意幸存者偏差

只看到“活下来”的数据，会高估成功率。比如只分析活跃用户，会忽略流失用户。
异常值可能毁掉统计结果

平均值对极端值很敏感。分析数据时要看中位数、分位数，不要只看平均。
训练集和测试集要分开

在训练数据上表现好，不代表在真实数据上也好。交叉验证是基本操作。

6. 图论与离散数学：描述“状态”与“连接”

6.1 一句话理解图论

图论研究的是节点和节点之间的连接。对程序员来说：

只要问题能画成“点”和“线”，就可以用图论来解决。

6.2 先修复习：节点、边、度与图的两种存法

1. 基本概念

节点（顶点）：图里的“点”，可以代表人、网页、城市；
边：节点之间的“连线”，代表关系；
有向 vs 无向：微博“关注”是有向的（你关注他，他不一定关注你），微信好友是无向的；
权重：边上挂的数字，比如两个城市之间的距离。

2. 一个 3 节点小图的两种表示

假设一个无向图：A 和 B 之间有一条权重 2 的边，A 和 C 之间有一条权重 5 的边，B 和 C 之间没有边。

邻接矩阵：用一张 $3 \times 3$ 的表，第 $i$ 行第 $j$ 列存节点 $i$ 到节点 $j$ 的边权，0 表示没边：

$$ \begin{bmatrix} 0 & 2 & 5 \\ 2 & 0 & 0 \\ 5 & 0 & 0 \end{bmatrix} $$

（无向图的邻接矩阵一定是对称的。）

邻接表：每个节点挂一个列表，只记录真实存在的边：

A → [(B, 2), (C, 5)]
B → [(A, 2)]
C → [(A, 5)]

该用哪种？ 邻接矩阵查询快但占 $n^2$ 空间（$n$ 是节点数），适合边很多的稠密图；邻接表只占和“节点数 + 边数”成正比的空间，适合边很少的稀疏图。社交网络这种“人均几百好友”的图就是稀疏图，工程上基本都用邻接表。

3. 度：一个节点有几条边

度 = 连在一个节点上的边的数量。上面的图里：A 的度是 2，B 和 C 的度都是 1。有向图还要分入度（多少条边指向我）和出度（我指向多少条边）——6.4 节 PageRank 里“被多少重要网页链接”，数的就是入度。

6.3 核心概念速查

概念	程序员直觉	软件行业用途
图	节点 + 边	社交网络、网页链接、知识图谱
最短路径	两点之间代价最小的路径	地图导航、网络路由
拓扑排序	有依赖关系的任务排序	编译依赖、工作流调度
有限状态机	系统在有限状态间转移	正则表达式、协议设计
Trie 树	前缀树	搜索引擎提示、自动补全

6.4 典型场景：网页排名与 PageRank

互联网可以看作一张有向图：网页是节点，超链接是边。

PageRank 的核心思想：一个网页的重要性，取决于链接到它的网页有多重要。

flowchart LR
    A[网页 A] --> B[网页 B]
    C[网页 C] --> B
    B --> D[网页 D]
    D --> A

数学上，PageRank 向量 $\mathbf{r}$ 满足：

$$ \mathbf{r} = d M \mathbf{r} + \frac{1-d}{N} \mathbf{1} $$

其中 $M$ 是转移矩阵，$d$ 是阻尼系数（通常取 0.85），$N$ 是网页总数。

这个公式同时用到了：

图论：网页链接关系
线性代数：转移矩阵和特征向量
概率论：随机冲浪模型

6.5 典型场景：有限状态机在词法分析中的应用

编译器识别一个标识符、数字或关键字时，用的就是有限状态机（FSM）。

flowchart LR
    S0[开始] -->|字母| S1[标识符]
    S1 -->|字母/数字| S1
    S0 -->|数字| S2[数字]
    S2 -->|数字| S2

正则表达式的底层也可以用有限状态机实现。理解 FSM，对写解析器、协议状态机都非常有帮助。

6.6 图论避坑技巧

图不一定是对称的

网页链接、关注关系都是有向图。不要用无向图的算法硬套。
注意自环和重边

实现图算法时，自环节点和多条边会影响结果，要提前处理。
大图要考虑存储方式

邻接矩阵适合稠密图，邻接表适合稀疏图。百亿级别边必须用分布式图计算框架。
状态机要覆盖所有输入

设计 FSM 时，每个状态对每个可能输入都要有定义，否则会出现未定义行为。
最短路径算法要选对
- Dijkstra：无负权边，单源最短路。
- Bellman-Ford：有负权边。
- Floyd：多源最短路。
- BFS：无权图最短路。

7. 优化算法：在复杂空间中找到“好答案”

7.1 一句话理解优化算法

优化算法研究的是如何高效地找到最优或近似最优解。对程序员来说：

很多问题没有闭式解，必须用迭代方法一步步逼近答案。

7.2 先修复习：优化三要素、为什么迭代、记忆化与贪心

1. 优化问题的三要素

任何优化问题都可以拆成三件事：

变量：你能调的东西（比如模型的参数）；
目标函数：你想最大化或最小化的东西（比如“预测误差最小”）；
约束：不能违反的条件（比如“预算不超过 100 万”）。

2. 为什么没有一步到位的公式？

中学解方程 $x^2 - 2x = 0$ 有求根公式，一步到位。但真实问题的目标函数往往太复杂（几亿个变量、函数嵌套几十层），不存在能直接写出答案的公式（闭式解），只能“迭代逼近”：先随便猜一个答案，算一算离最优还差多远、该往哪个方向调，调完再算，循环成千上万次。梯度下降、EM 算法都是这种思路。

3. 动态规划：记住算过的，别重复算

用斐波那契数列（$f(n) = f(n-1) + f(n-2)$，$f(1) = f(2) = 1$）对比两种算法。朴素递归算 $f(5)$：

f(5) = f(4) + f(3)
f(4) = f(3) + f(2)   ← f(3) 第二次出现
f(3) = f(2) + f(1)   ← f(2) 也被反复重算

$f(3)$ 被完整重算了 2 次，$f(2)$ 被重算 3 次；$n$ 稍大一点，重复计算就爆炸式增长。动态规划（记忆化）的做法：算过的结果存进数组，下次直接查表，每个 $f(i)$ 只算一次，$n$ 步搞定。“存在重复子问题”是判断能不能用 DP 的标志。

4. 贪心：每步拿当前最好

贪心算法的直觉：每走一步都选眼前最好的选择，不回看、不后悔。比如用 1 元、5 角、1 角的硬币凑 1.8 元：先拿 1 元（能拿的最大面额），再拿 5 角，再拿 3 个 1 角。很多场景贪心足够好（7.4 节分词里的局部最优选择就有它的影子），但要注意它不一定能得到全局最优。

7.3 核心概念速查

算法	核心思想	软件行业用途
梯度下降	沿负梯度方向更新	深度学习训练
动态规划	把大问题拆成重叠子问题	最短路径、编辑距离、分词
贪心算法	每步选局部最优	哈夫曼编码、活动安排
EM 算法	期望-最大化迭代	隐变量模型、聚类
维特比算法	动态规划找最优路径	语音识别、HMM 解码

7.4 典型场景：动态规划做中文分词

中文分词没有天然空格，需要判断“结合成/分子/情况”还是“结合/成分/子情况”。

一种简单思路是：把句子切成词序列，让整体概率最大。

$$ \text{最佳切分} = \arg\max_{\text{切分方式}} P(\text{切分方式} \mid \text{句子}) $$

用动态规划可以高效求解：

flowchart LR
    A[句子起始] --> B[考虑第一个词]
    B --> C[剩余子问题]
    C --> D[递归求解]
    D --> E[取概率最大的路径]

例如“研究生命”可以切成“研究/生命”或“研究生/命”。统计语言模型会选概率更高的切分。

7.5 典型场景：维特比算法与语音识别

语音识别的任务是：给定声学信号，找出最可能的文字序列。

Hidden Markov Model（HMM）把这个问题建模为：

$$ \hat{W} = \arg\max_W P(W \mid \text{声学信号}) = \arg\max_W P(\text{声学信号} \mid W) \cdot P(W) $$

维特比算法用动态规划，在状态序列中找出概率最大的路径，避免枚举所有可能。

flowchart TD
    A[声学特征序列] --> B[每个时刻计算各状态概率]
    B --> C[只保留到达每个状态的最优路径]
    C --> D[递推到最后一帧]
    D --> E[回溯得到最优词序列]

7.6 优化算法避坑技巧

动态规划要能定义“状态”和“转移”

不是所有问题都适合 DP。关键是找到无后效性的子问题。
贪心算法不一定最优

贪心只在具有“最优子结构”和“贪心选择性质”的问题上才能得到全局最优。
EM 算法对初始值敏感

不同的初始化可能收敛到不同的局部最优。通常需要多次随机初始化。
不要迷信“最优”

工程上很多时候“足够好”比“理论最优”更重要。启发式算法往往更实用。
注意时间复杂度

动态规划虽然比暴力快，但状态空间太大时也会超时。要会分析复杂度。

8. NLP 中的数学：让机器“理解”语言

8.1 一句话理解 NLP 数学

自然语言处理的核心数学问题是：

把离散的、有歧义的语言，转化为可以计算的概率或向量。

8.2 先修复习：先把文本变成数字

计算机只认数字，不认汉字。NLP 的一切数学操作之前，都有一步“文本 → 数字”的转换。

1. one-hot：一个词一个位置

假设词表只有 4 个词：[我, 爱, 北京, 上海]。one-hot 表示就是“词表里有几个词，向量就有几维；是哪个词，对应位置为 1，其余为 0”：

我   → [1, 0, 0, 0]
爱   → [0, 1, 0, 0]
北京 → [0, 0, 1, 0]

2. 词袋：一句话一个计数向量

词袋（Bag of Words）表示一整句话：向量的每个位置记录该词在句中出现了几次。两个短句：

句1：我 爱 北京  → [1, 1, 1, 0]
句2：我 爱 上海  → [1, 1, 0, 1]

注意它丢掉了语序——“我爱北京”和“北京爱我”的词袋向量一模一样。这是词袋模型的硬伤，但作为第一步表示已经够用。

这和后面的工程应用有什么关系？ 8.4 节的 TF-IDF，就是给词袋向量的每一维乘上一个“区分度权重”；8.5 节的语言模型和机器翻译，则是在“文本已经变成数字序列”的前提下算概率。现代词向量（word2vec）本质上也是 one-hot 经过一层矩阵乘法压缩出来的稠密向量——看到“矩阵乘法”，可以翻回 1.2 节复习。

8.3 核心任务速查

任务	数学工具	工程价值
中文分词	统计语言模型 + 动态规划	搜索、输入法、文本分析
词性标注	HMM / CRF	句法分析、信息抽取
语音识别	HMM + 高斯混合模型	语音助手、输入法
机器翻译	统计翻译模型 / 神经网络	跨语言交流
信息检索	TF-IDF + 向量空间模型	搜索引擎、推荐

8.4 典型场景：TF-IDF 与搜索排序

搜索引擎怎么判断一个网页和查询词有多相关？TF-IDF 是最经典的方案：

$$ \text{TF-IDF}(t, d) = \text{TF}(t, d) \times \text{IDF}(t) $$

其中：

TF（词频）：词 $t$ 在文档 $d$ 中出现多少次。
IDF（逆文档频率）：$\log \frac{N}{|{d: t \in d}|}$，衡量词的区分能力。

“的”“是”这种词出现很多但 IDF 很低，不会拉高排序；“量子计算”出现少但 IDF 高，更有区分度。

flowchart LR
    Q[用户查询] -->|分词| T[关键词]
    T -->|计算 TF-IDF| S[候选文档得分]
    S -->|排序| R[返回结果]

8.5 典型场景：统计机器翻译

早期机器翻译用统计模型，把翻译问题建模为：

$$ \hat{e} = \arg\max_e P(e \mid f) = \arg\max_e P(f \mid e) \cdot P(e) $$

其中：

$P(e)$ 是目标语言模型，判断翻译结果是否通顺。
$P(f \mid e)$ 是翻译模型，判断源语言到目标语言的对应关系。

flowchart LR
    F[外语句子 f] -->|翻译模型| C[候选译文集合]
    C -->|语言模型打分| S[选择最通顺的译文]
    S --> E[目标语言句子 e]

现代神经机器翻译用 Transformer 替代了这些统计模型，但“源语言 → 候选 → 语言模型打分”的直觉仍然成立。

8.6 NLP 数学避坑技巧

语言模型不是真的“理解”语言

它只是统计规律。不要对输出结果赋予过多“智能”含义。
分词结果影响后续所有任务

中文分词错误会级联传播。搜索里“南京市/长江大桥”和“南京/市长/江大桥”完全不是一回事。
TF-IDF 忽略语义

它只看词频，不处理同义词。现代搜索会用向量语义模型做补充。
数据预处理占 80% 工作量

去噪、归一化、编码处理往往比模型本身更费时间。
不要忽视评估指标

BLEU、ROUGE、准确率、召回率、F1 各有适用场景。单一看指标容易误判。

9. 多门数学如何协同工作？

真实工程中，这些数学工具很少单独出现，它们通常协同作战。

9.1 一个典型 AI 项目的数学全景

flowchart TD
    subgraph 数据层
        D1[原始数据] --> D2[清洗 / 采样 / 特征工程]
    end

    subgraph 建模层
        D2 --> L1[线性代数<br/>把特征表示成向量/矩阵]
        L1 --> L2[概率论<br/>定义损失/似然函数]
        L2 --> L3[信息论<br/>交叉熵 / KL 散度]
        L3 --> L4[微积分<br/>梯度下降优化参数]
        L4 --> L5[优化算法<br/>DP / EM / 贪心]
    end

    subgraph 输出层
        L5 --> O1[训练好的模型]
        O1 --> O2[预测/推理]
    end

9.2 案例：逻辑回归

逻辑回归是分类问题的“基线模型”，同时用到了三种数学：

线性代数：把输入特征加权求和

$$ z = \mathbf{w}^T \mathbf{x} + b $$
概率论：用 sigmoid 函数把 $z$ 映射成概率

$$ P(y=1 \mid \mathbf{x}) = \sigma(z) = \frac{1}{1 + e^{-z}} $$
微积分 + 信息论：用梯度下降最小化交叉熵损失

$$ L = -\left[ y \log \hat{y} + (1-y) \log(1-\hat{y}) \right] $$

flowchart LR
    X["特征向量 x"] -->|"w^T x + b"| Z["线性组合 z"]
    Z -->|"sigmoid"| P["概率 ŷ"]
    P -->|"交叉熵损失"| L["损失 L"]
    L -->|"梯度下降"| W["更新 w, b"]

9.3 案例：PageRank

Google 的 PageRank 算法是多种数学结合的典型：

图论：网页之间的链接关系
线性代数：网页链接表示成转移矩阵 $M$
概率论：把随机冲浪者停留在某个网页的概率作为网页重要性
特征值：PageRank 向量就是矩阵 $M$ 的主特征向量

$$ \mathbf{r} = d M \mathbf{r} + \frac{1-d}{N} \mathbf{1} $$

其中 $d$ 是阻尼系数，$N$ 是网页总数。

10. 给新人的学习路线图

10.1 推荐学习顺序

flowchart LR
    A[高中数学复习<br/>函数、方程] --> B[线性代数基础<br/>向量、矩阵、乘法]
    B --> C[微积分基础<br/>导数、偏导、梯度]
    C --> D[概率论基础<br/>条件概率、分布、期望]
    D --> E[信息论入门<br/>熵、交叉熵]
    E --> F[统计学入门<br/>采样、假设检验]
    F --> G[离散数学/图论<br/>图、状态机]
    G --> H[优化算法<br/>DP、贪心、EM]
    H --> I[结合项目学习<br/>NLP / 推荐 / 搜索]
    I --> J[读《数学之美》<br/>看工程案例]

10.2 学习资源建议

阶段	推荐资源	目标
入门	3Blue1Brown《线性代数的本质》	建立几何直觉
入门	3Blue1Brown《微积分的本质》	理解导数和积分
入门	3Blue1Brown《概率论》	理解概率直觉
入门	3Blue1Brown《信息论》	理解熵和编码
实践	吴军《数学之美》	看真实工程案例
深入	《统计学习方法》/《机器学习》周志华	系统学习算法
深入	《算法导论》	系统学习优化与数据结构

10.3 新人最常犯的 5 个错误

只看公式，不画图

数学公式是压缩后的表达。先用图像、例子理解，再看公式会轻松很多。
追求严格证明，忽视直觉

对程序员来说，先知道“为什么有用”比“怎么严格证明”更重要。
不跑代码，只看书

用 NumPy 写一遍矩阵乘法、梯度下降，理解会深很多。
跳得太快，基础不牢

不要还没搞懂向量和矩阵，就直接去看 Transformer。基础不稳，后面全是黑魔法。
学了不用，很快忘记

选一个实际项目（比如用逻辑回归做分类、用协同过滤做推荐、用 TF-IDF 做搜索），把数学用起来。

11. 避坑总结：一张图记住要点

mindmap
  root((数学之美<br/>避坑指南))
    线性代数
      先看形状再算
      区分矩阵乘和逐元素乘
      稀疏矩阵别用稠密存
      特征值不是玄学
    微积分
      梯度要加负号
      学习率要调参
      框架能自动求导但原理要懂
      局部最小不必纠结
    概率论
      概率高不等于一定发生
      条件概率方向别搞反
      零概率要平滑
      数据量决定模型上限
    信息论
      熵大不等于信息多
      交叉熵配合 softmax
      KL 散度不对称
    统计学
      相关不等于因果
      样本量要足够
      训练集测试集要分开
    图论与优化
      有向图无向图别混
      贪心不一定最优
      DP 状态定义要无后效性
    通用
      先直觉后证明
      一定要写代码
      用项目驱动学习

12. 结语：数学是程序员的“第二门语言”

《数学之美》让我印象最深的一点是：很多复杂问题，其实都有简洁的数学表达。线性代数让我们能批量处理关系，微积分让我们能自动优化，概率论让我们能坦然面对不确定性，信息论让我们能量化信息，统计学让我们能从数据中提炼规律，图论和优化算法让我们能高效搜索复杂空间。

作为新人，不必一开始就精通所有推导。重要的是建立直觉：

看到矩阵，想到“关系和变换”。
看到导数，想到“变化和优化方向”。
看到概率，想到“不确定性和可能性”。
看到熵，想到“信息量和不确定性”。
看到图，想到“节点和连接”。
看到优化问题，想到“状态、转移、目标函数”。

当你能把业务问题翻译成数学问题，再用代码实现出来，你就已经从“写代码的人”成长为“解决问题的人”了。

希望这篇总结对你有帮助。如果有具体概念想深入，欢迎在评论区交流。

参考与延伸阅读

吴军《数学之美》
3Blue1Brown 系列视频（B 站/YouTube）
周志华《机器学习》
李航《统计学习方法》
Thomas M. Cover《信息论基础》
《算法导论》